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.

Tips for patch submitters
-------------------------

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. See
	Documentation/admin-guide/security-bugs.rst for details.

8.	Happy hacking.

Descriptions of section entries and preferred order
---------------------------------------------------

	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
	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.
	W: *Web-page* with status/info
	Q: *Patchwork* web based patch tracking system site
	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.
	P: Subsystem Profile document for more details submitting
	   patches to the given subsystem. This is either an in-tree file,
	   or a URI. See Documentation/maintainer/maintainer-entry-profile.rst
	   for details.
	T: *SCM* tree type and location.
	   Type is one of: git, hg, quilt, stgit, topgit
	F: *Files* and directories 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.
	X: *Excluded* 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/
	N: Files and directories *Regex* patterns.
	   N:	[^a-z]tegra	all files whose path contains tegra
	                        (not including files like integrator)
	   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.
	K: *Content regex* (perl extended) pattern match 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.

Maintainers List
----------------

.. note:: When reading this list, please look for the most precise areas
          first. When adding to this list, please keep the entries in
          alphabetical order.

3C59X NETWORK DRIVER
M:	Steffen Klassert <klassert@kernel.org>
L:	netdev@vger.kernel.org
S:	Odd Fixes
F:	Documentation/networking/device_drivers/ethernet/3com/vortex.rst
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
S:	Supported
W:	http://www.lsi.com
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>
L:	linux-bluetooth@vger.kernel.org
L:	linux-wpan@vger.kernel.org
S:	Maintained
F:	Documentation/networking/6lowpan.rst
F:	include/net/6lowpan.h
F:	net/6lowpan/

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

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

8169 10/100/1000 GIGABIT ETHERNET DRIVER
M:	Heiner Kallweit <hkallweit1@gmail.com>
M:	nic_swsd@realtek.com
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/realtek/r8169*

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:	Latchesar Ionkov <lucho@ionkov.net>
M:	Dominique Martinet <asmadeus@codewreck.org>
R:	Christian Schoenebeck <linux_oss@crudebyte.com>
L:	v9fs-developer@lists.sourceforge.net
S:	Maintained
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
T:	git git://github.com/martinetd/linux.git
F:	Documentation/filesystems/9p.rst
F:	fs/9p/
F:	include/net/9p/
F:	include/trace/events/9p.h
F:	include/uapi/linux/virtio_9p.h
F:	net/9p/

A64FX DIAG DRIVER
M:	Hitomi Hasegawa <hasegawa-hitomi@fujitsu.com>
S:	Supported
F:	drivers/soc/fujitsu/a64fx-diag.c

A8293 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/a8293*

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

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

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 <william.gray@linaro.org>
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 <william.gray@linaro.org>
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 <william.gray@linaro.org>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-104-idio-16.c

ACCES 104-QUAD-8 DRIVER
M:	William Breathitt Gray <william.gray@linaro.org>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	drivers/counter/104-quad-8.c

ACCES PCI-IDIO-16 GPIO DRIVER
M:	William Breathitt Gray <william.gray@linaro.org>
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 <william.gray@linaro.org>
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 Kaestle <peter@piie.net>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
W:	http://piie.net/?section=acerhdf
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" <rafael@kernel.org>
R:	Len Brown <lenb@kernel.org>
L:	linux-acpi@vger.kernel.org
S:	Supported
W:	https://01.org/linux-acpi
Q:	https://patchwork.kernel.org/project/linux-acpi/list/
B:	https://bugzilla.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
F:	Documentation/ABI/testing/configfs-acpi
F:	Documentation/ABI/testing/sysfs-bus-acpi
F:	Documentation/firmware-guide/acpi/
F:	drivers/acpi/
F:	drivers/pci/*/*acpi*
F:	drivers/pci/*acpi*
F:	drivers/pnp/pnpacpi/
F:	include/acpi/
F:	include/linux/acpi.h
F:	include/linux/fwnode.h
F:	tools/power/acpi/

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

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

ACPI FOR ARM64 (ACPI/arm64)
M:	Lorenzo Pieralisi <lpieralisi@kernel.org>
M:	Hanjun Guo <guohanjun@huawei.com>
M:	Sudeep Holla <sudeep.holla@arm.com>
L:	linux-acpi@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/acpi/arm64

ACPI SERIAL MULTI INSTANTIATE DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/serial-multi-instantiate.c

ACPI PCC(Platform Communication Channel) MAILBOX DRIVER
M:	Sudeep Holla <sudeep.holla@arm.com>
L:	linux-acpi@vger.kernel.org
S:	Supported
F:	drivers/mailbox/pcc.c

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

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

ACPI VIOT DRIVER
M:	Jean-Philippe Brucker <jean-philippe@linaro.org>
L:	linux-acpi@vger.kernel.org
L:	iommu@lists.linux.dev
S:	Maintained
F:	drivers/acpi/viot.c
F:	include/linux/acpi_viot.h

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

ACRN HYPERVISOR SERVICE MODULE
M:	Fei Li <fei1.li@intel.com>
L:	acrn-dev@lists.projectacrn.org (subscribers-only)
S:	Supported
W:	https://projectacrn.org
F:	Documentation/virt/acrn/
F:	drivers/virt/acrn/
F:	include/uapi/linux/acrn.h

AD1889 ALSA SOUND DRIVER
L:	linux-parisc@vger.kernel.org
S:	Maintained
W:	https://parisc.wiki.kernel.org/index.php/AD1889
F:	sound/pci/ad1889.*

AD5110 ANALOG DEVICES DIGITAL POTENTIOMETERS DRIVER
M:	Mugilraj Dhavachelvan <dmugil2000@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Supported
F:	drivers/iio/potentiometer/ad5110.c

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

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

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

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

AD7879 TOUCHSCREEN DRIVER (AD7879/AD7889)
M:	Michael Hennerich <michael.hennerich@analog.com>
S:	Supported
W:	http://wiki.analog.com/AD7879
W:	https://ez.analog.com/linux-software-drivers
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>
L:	linux-wpan@vger.kernel.org
S:	Supported
W:	https://wiki.analog.com/ADF7242
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/net/ieee802154/adf7242.txt
F:	drivers/net/ieee802154/adf7242.c

ADM1025 HARDWARE MONITOR DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/adm1025.rst
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
S:	Orphan
W:	https://wireless.wiki.kernel.org/
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>
S:	Supported
W:	http://wiki.analog.com/ADP5520
W:	https://ez.analog.com/linux-software-drivers
F:	drivers/gpio/gpio-adp5520.c
F:	drivers/input/keyboard/adp5520-keys.c
F:	drivers/leds/leds-adp5520.c
F:	drivers/mfd/adp5520.c
F:	drivers/video/backlight/adp5520_bl.c

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

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

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.rst
F:	drivers/hwmon/adt7475.c

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

ADVANTECH SWBTN DRIVER
M:	Andrea Ho <Andrea.Ho@advantech.com.tw>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/adv_swbutton.c

ADXL313 THREE-AXIS DIGITAL ACCELEROMETER DRIVER
M:	Lucas Stankus <lucas.p.stankus@gmail.com>
S:	Supported
F:	Documentation/devicetree/bindings/iio/accel/adi,adxl313.yaml
F:	drivers/iio/accel/adxl313*

ADXL34X THREE-AXIS DIGITAL ACCELEROMETER DRIVER (ADXL345/ADXL346)
M:	Michael Hennerich <michael.hennerich@analog.com>
S:	Supported
W:	http://wiki.analog.com/ADXL345
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/accel/adi,adxl345.yaml
F:	drivers/input/misc/adxl34x.c

ADXL355 THREE-AXIS DIGITAL ACCELEROMETER DRIVER
M:	Puranjay Mohan <puranjay12@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/iio/accel/adi,adxl355.yaml
F:	drivers/iio/accel/adxl355.h
F:	drivers/iio/accel/adxl355_core.c
F:	drivers/iio/accel/adxl355_i2c.c
F:	drivers/iio/accel/adxl355_spi.c

ADXL367 THREE-AXIS DIGITAL ACCELEROMETER DRIVER
M:	Cosmin Tanislav <cosmin.tanislav@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	http://ez.analog.com/community/linux-device-drivers
F:	Documentation/devicetree/bindings/iio/accel/adi,adxl367.yaml
F:	drivers/iio/accel/adxl367*

ADXL372 THREE-AXIS DIGITAL ACCELEROMETER DRIVER
M:	Michael Hennerich <michael.hennerich@analog.com>
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/accel/adi,adxl372.yaml
F:	drivers/iio/accel/adxl372.c
F:	drivers/iio/accel/adxl372_i2c.c
F:	drivers/iio/accel/adxl372_spi.c

AF9013 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/af9013*

AF9033 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
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.rst
F:	fs/affs/

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

AGPGART DRIVER
M:	David Airlie <airlied@linux.ie>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm
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
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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
S:	Maintained
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
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
S:	Maintained
W:	http://www.linux-usb.org/SpeedTouch/
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.rst
F:	drivers/i2c/busses/i2c-ali1563.c

ALIBABA ELASTIC RDMA DRIVER
M:	Cheng Xu <chengyou@linux.alibaba.com>
M:	Kai Shen <kaishen@linux.alibaba.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
F:	drivers/infiniband/hw/erdma
F:	include/uapi/rdma/erdma-abi.h

ALIENWARE WMI DRIVER
L:	Dell.Client.Kernel@dell.com
S:	Maintained
F:	drivers/platform/x86/dell/alienware-wmi.c

ALL SENSORS DLH SERIES PRESSURE SENSORS DRIVER
M:	Tomislav Denis <tomislav.denis@avl.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
W:	http://www.allsensors.com/
F:	Documentation/devicetree/bindings/iio/pressure/asc,dlhl60d.yaml
F:	drivers/iio/pressure/dlhl60d.c

ALLEGRO DVT VIDEO IP CORE DRIVER
M:	Michael Tretter <m.tretter@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/allegro,al5e.yaml
F:	drivers/media/platform/allegro-dvt/

ALLWINNER A10 CSI DRIVER
M:	Maxime Ripard <mripard@kernel.org>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/allwinner,sun4i-a10-csi.yaml
F:	drivers/media/platform/sunxi/sun4i-csi/

ALLWINNER A31 MIPI CSI-2 BRIDGE DRIVER
M:	Paul Kocialkowski <paul.kocialkowski@bootlin.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/allwinner,sun6i-a31-mipi-csi2.yaml
F:	drivers/media/platform/sunxi/sun6i-mipi-csi2/

ALLWINNER CPUFREQ DRIVER
M:	Yangtao Li <tiny.windzz@gmail.com>
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/opp/allwinner,sun50i-h6-operating-points.yaml
F:	drivers/cpufreq/sun50i-cpufreq-nvmem.c

ALLWINNER CRYPTO DRIVERS
M:	Corentin Labbe <clabbe.montjoie@gmail.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/allwinner/

ALLWINNER HARDWARE SPINLOCK SUPPORT
M:	Wilken Gottwalt <wilken.gottwalt@posteo.net>
S:	Maintained
F:	Documentation/devicetree/bindings/hwlock/allwinner,sun6i-a31-hwspinlock.yaml
F:	drivers/hwspinlock/sun6i_hwspinlock.c

ALLWINNER THERMAL DRIVER
M:	Vasily Khoruzhick <anarsoul@gmail.com>
M:	Yangtao Li <tiny.windzz@gmail.com>
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/thermal/allwinner,sun8i-a83t-ths.yaml
F:	drivers/thermal/sun8i_thermal.c

ALLWINNER VPU DRIVER
M:	Maxime Ripard <mripard@kernel.org>
M:	Paul Kocialkowski <paul.kocialkowski@bootlin.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/staging/media/sunxi/cedrus/

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

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

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

ALTERA MAILBOX DRIVER
M:	Mun Yew Tham <mun.yew.tham@intel.com>
S:	Maintained
F:	drivers/mailbox/mailbox-altera.c

ALTERA MSGDMA IP CORE DRIVER
M:	Olivier Dautricourt <olivierdautricourt@gmail.com>
R:	Stefan Roese <sr@denx.de>
L:	dmaengine@vger.kernel.org
S:	Odd Fixes
F:	Documentation/devicetree/bindings/dma/altr,msgdma.yaml
F:	drivers/dma/altera-msgdma.c

ALTERA PIO DRIVER
M:	Mun Yew Tham <mun.yew.tham@intel.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-altera.c

ALTERA SYSTEM MANAGER DRIVER
M:	Thor Thayer <thor.thayer@linux.intel.com>
S:	Maintained
F:	drivers/mfd/altera-sysmgr.c
F:	include/linux/mfd/altera-sysmgr.h

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/dt-bindings/reset/altr,rst-mgr-a10sr.h
F:	include/linux/mfd/altera-a10sr.h

ALTERA TRIPLE SPEED ETHERNET DRIVER
M:	Joyce Ooi <joyce.ooi@intel.com>
L:	netdev@vger.kernel.org
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
S:	Maintained
F:	drivers/tty/serial/altera_jtaguart.c
F:	drivers/tty/serial/altera_uart.c
F:	include/linux/altera_jtaguart.h
F:	include/linux/altera_uart.h

AMAZON ANNAPURNA LABS FIC DRIVER
M:	Talel Shenhar <talel@amazon.com>
S:	Maintained
F:	Documentation/devicetree/bindings/interrupt-controller/amazon,al-fic.txt
F:	drivers/irqchip/irq-al-fic.c

AMAZON ANNAPURNA LABS MEMORY CONTROLLER EDAC
M:	Talel Shenhar <talel@amazon.com>
M:	Talel Shenhar <talelshenhar@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/edac/amazon,al-mc-edac.yaml
F:	drivers/edac/al_mc_edac.c

AMAZON ANNAPURNA LABS THERMAL MMIO DRIVER
M:	Talel Shenhar <talel@amazon.com>
S:	Maintained
F:	Documentation/devicetree/bindings/thermal/amazon,al-thermal.txt
F:	drivers/thermal/thermal_mmio.c

AMAZON ETHERNET DRIVERS
M:	Shay Agroskin <shayagr@amazon.com>
M:	Arthur Kiyanovski <akiyano@amazon.com>
R:	David Arinzon <darinzon@amazon.com>
R:	Noam Dagan <ndagan@amazon.com>
R:	Saeed Bishara <saeedb@amazon.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/device_drivers/ethernet/amazon/ena.rst
F:	drivers/net/ethernet/amazon/

AMAZON RDMA EFA DRIVER
M:	Gal Pressman <galpress@amazon.com>
R:	Yossi Leybovich <sleybo@amazon.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-rdma/list/
F:	drivers/infiniband/hw/efa/
F:	include/uapi/rdma/efa-abi.h

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

AMD CRYPTOGRAPHIC COPROCESSOR (CCP) DRIVER - SEV SUPPORT
M:	Brijesh Singh <brijesh.singh@amd.com>
M:	Tom Lendacky <thomas.lendacky@amd.com>
L:	linux-crypto@vger.kernel.org
S:	Supported
F:	drivers/crypto/ccp/sev*
F:	include/uapi/linux/psp-sev.h

AMD DISPLAY CORE
M:	Harry Wentland <harry.wentland@amd.com>
M:	Leo Li <sunpeng.li@amd.com>
M:	Rodrigo Siqueira <Rodrigo.Siqueira@amd.com>
L:	amd-gfx@lists.freedesktop.org
S:	Supported
T:	git https://gitlab.freedesktop.org/agd5f/linux.git
F:	drivers/gpu/drm/amd/display/

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.rst
F:	drivers/hwmon/fam15h_power.c

AMD FCH GPIO DRIVER
M:	Enrico Weigelt, metux IT consult <info@metux.net>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-amd-fch.c
F:	include/linux/platform_data/gpio/gpio-amd-fch.h

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

AMD IOMMU (AMD-VI)
M:	Joerg Roedel <joro@8bytes.org>
R:	Suravee Suthikulpanit <suravee.suthikulpanit@amd.com>
L:	iommu@lists.linux.dev
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git
F:	drivers/iommu/amd/
F:	include/linux/amd-iommu.h

AMD KFD
M:	Felix Kuehling <Felix.Kuehling@amd.com>
L:	amd-gfx@lists.freedesktop.org
S:	Supported
T:	git https://gitlab.freedesktop.org/agd5f/linux.git
F:	drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd*.[ch]
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/v9_structs.h
F:	drivers/gpu/drm/amd/include/vi_structs.h
F:	include/uapi/linux/kfd_ioctl.h
F:	include/uapi/linux/kfd_sysfs.h

AMD SPI DRIVER
M:	Sanjay R Mehta <sanju.mehta@amd.com>
S:	Maintained
F:	drivers/spi/spi-amd.c

AMD MP2 I2C DRIVER
M:	Elie Morisse <syniurge@gmail.com>
M:	Nehal Shah <nehal-bakulchandra.shah@amd.com>
M:	Shyam Sundar S K <shyam-sundar.s-k@amd.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/busses/i2c-amd-mp2*

AMD PMC DRIVER
M:	Shyam Sundar S K <Shyam-sundar.S-k@amd.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/amd/pmc.c

AMD HSMP DRIVER
M:	Naveen Krishna Chatradhi <naveenkrishna.chatradhi@amd.com>
R:	Carlos Bilbao <carlos.bilbao@amd.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	Documentation/x86/amd_hsmp.rst
F:	arch/x86/include/asm/amd_hsmp.h
F:	arch/x86/include/uapi/asm/amd_hsmp.h
F:	drivers/platform/x86/amd/hsmp.c

AMD POWERPLAY AND SWSMU
M:	Evan Quan <evan.quan@amd.com>
L:	amd-gfx@lists.freedesktop.org
S:	Supported
T:	git https://gitlab.freedesktop.org/agd5f/linux.git
F:	drivers/gpu/drm/amd/pm/

AMD PSTATE DRIVER
M:	Huang Rui <ray.huang@amd.com>
L:	linux-pm@vger.kernel.org
S:	Supported
F:	Documentation/admin-guide/pm/amd-pstate.rst
F:	drivers/cpufreq/amd-pstate*
F:	tools/power/x86/amd_pstate_tracer/amd_pstate_trace.py

AMD PTDMA DRIVER
M:	Sanjay R Mehta <sanju.mehta@amd.com>
L:	dmaengine@vger.kernel.org
S:	Maintained
F:	drivers/dma/ptdma/

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>
M:	"Shyam Sundar S K" <Shyam-sundar.S-k@amd.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	arch/arm64/boot/dts/amd/amd-seattle-xgbe*.dtsi
F:	drivers/net/ethernet/amd/xgbe/

AMD SENSOR FUSION HUB DRIVER
M:	Basavaraj Natikar <basavaraj.natikar@amd.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	Documentation/hid/amd-sfh*
F:	drivers/hid/amd-sfh-hid/

AMPHION VPU CODEC V4L2 DRIVER
M:	Ming Qian <ming.qian@nxp.com>
M:	Shijie Qin <shijie.qin@nxp.com>
M:	Zhou Peng <eagle.zhou@nxp.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/amphion,vpu.yaml
F:	drivers/media/platform/amphion/

AMS AS73211 DRIVER
M:	Christian Eggers <ceggers@arri.de>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/light/ams,as73211.yaml
F:	drivers/iio/light/as73211.c

AMT (Automatic Multicast Tunneling)
M:	Taehee Yoo <ap420073@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git
F:	drivers/net/amt.c

ANALOG DEVICES INC AD7192 DRIVER
M:	Alexandru Tachici <alexandru.tachici@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/adc/adi,ad7192.yaml
F:	drivers/iio/adc/ad7192.c

ANALOG DEVICES INC AD7292 DRIVER
M:	Marcelo Schmitt <marcelo.schmitt1@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/adc/adi,ad7292.yaml
F:	drivers/iio/adc/ad7292.c

ANALOG DEVICES INC AD3552R DRIVER
M:	Nuno Sá <nuno.sa@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/dac/adi,ad3552r.yaml
F:	drivers/iio/dac/ad3552r.c

ANALOG DEVICES INC AD7293 DRIVER
M:	Antoniu Miclaus <antoniu.miclaus@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/dac/adi,ad7293.yaml
F:	drivers/iio/dac/ad7293.c

ANALOG DEVICES INC AD7768-1 DRIVER
M:	Michael Hennerich <Michael.Hennerich@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/adc/adi,ad7768-1.yaml
F:	drivers/iio/adc/ad7768-1.c

ANALOG DEVICES INC AD7780 DRIVER
M:	Michael Hennerich <Michael.Hennerich@analog.com>
M:	Renato Lui Geh <renatogeh@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/adc/adi,ad7780.yaml
F:	drivers/iio/adc/ad7780.c

ANALOG DEVICES INC AD74413R DRIVER
M:	Cosmin Tanislav <cosmin.tanislav@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	http://ez.analog.com/community/linux-device-drivers
F:	Documentation/devicetree/bindings/iio/addac/adi,ad74413r.yaml
F:	drivers/iio/addac/ad74413r.c
F:	include/dt-bindings/iio/addac/adi,ad74413r.h

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

ANALOG DEVICES INC ADA4250 DRIVER
M:	Antoniu Miclaus <antoniu.miclaus@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/amplifiers/adi,ada4250.yaml
F:	drivers/iio/amplifiers/ada4250.c

ANALOG DEVICES INC ADGS1408 DRIVER
M:	Mircea Caprioru <mircea.caprioru@analog.com>
S:	Supported
F:	Documentation/devicetree/bindings/mux/adi,adgs1408.txt
F:	drivers/mux/adgs1408.c

ANALOG DEVICES INC ADIN DRIVER
M:	Michael Hennerich <michael.hennerich@analog.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/net/adi,adin.yaml
F:	drivers/net/phy/adin.c

ANALOG DEVICES INC ADIS DRIVER LIBRARY
M:	Nuno Sa <nuno.sa@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
F:	drivers/iio/imu/adis.c
F:	drivers/iio/imu/adis_buffer.c
F:	drivers/iio/imu/adis_trigger.c
F:	include/linux/iio/imu/adis.h

ANALOG DEVICES INC ADIS16460 DRIVER
M:	Dragos Bogdan <dragos.bogdan@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/imu/adi,adis16460.yaml
F:	drivers/iio/imu/adis16460.c

ANALOG DEVICES INC ADIS16475 DRIVER
M:	Nuno Sa <nuno.sa@analog.com>
L:	linux-iio@vger.kernel.org
W:	https://ez.analog.com/linux-software-drivers
S:	Supported
F:	drivers/iio/imu/adis16475.c
F:	Documentation/devicetree/bindings/iio/imu/adi,adis16475.yaml

ANALOG DEVICES INC ADM1177 DRIVER
M:	Michael Hennerich <Michael.Hennerich@analog.com>
L:	linux-hwmon@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/hwmon/adi,adm1177.yaml
F:	drivers/hwmon/adm1177.c

ANALOG DEVICES INC ADMV1013 DRIVER
M:	Antoniu Miclaus <antoniu.miclaus@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/frequency/adi,admv1013.yaml
F:	drivers/iio/frequency/admv1013.c

ANALOG DEVICES INC ADMV8818 DRIVER
M:	Antoniu Miclaus <antoniu.miclaus@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/filter/adi,admv8818.yaml
F:	drivers/iio/filter/admv8818.c

ANALOG DEVICES INC ADMV1014 DRIVER
M:	Antoniu Miclaus <antoniu.miclaus@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/frequency/adi,admv1014.yaml
F:	drivers/iio/frequency/admv1014.c

ANALOG DEVICES INC ADP5061 DRIVER
M:	Michael Hennerich <Michael.Hennerich@analog.com>
L:	linux-pm@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	drivers/power/supply/adp5061.c

ANALOG DEVICES INC ADRF6780 DRIVER
M:	Antoniu Miclaus <antoniu.miclaus@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/frequency/adi,adrf6780.yaml
F:	drivers/iio/frequency/adrf6780.c

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

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

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

ANALOG DEVICES INC ADV7604 DRIVER
M:	Hans Verkuil <hverkuil-cisco@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/adv7604*
F:	Documentation/devicetree/bindings/media/i2c/adv7604.yaml

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

ANALOG DEVICES INC ADXRS290 DRIVER
M:	Nishant Malpani <nish.malpani25@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Supported
F:	drivers/iio/gyro/adxrs290.c
F:	Documentation/devicetree/bindings/iio/gyroscope/adi,adxrs290.yaml

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

ANALOG DEVICES INC DMA DRIVERS
M:	Lars-Peter Clausen <lars@metafoo.de>
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
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>
S:	Supported
W:	http://wiki.analog.com/
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/ABI/testing/sysfs-bus-iio-frequency-ad9523
F:	Documentation/ABI/testing/sysfs-bus-iio-frequency-adf4350
F:	Documentation/devicetree/bindings/iio/*/adi,*
F:	Documentation/devicetree/bindings/iio/dac/adi,ad5758.yaml
F:	drivers/iio/*/ad*
F:	drivers/iio/adc/ltc249*
F:	drivers/iio/amplifiers/hmc425a.c
F:	drivers/staging/iio/*/ad*
X:	drivers/iio/*/adjd*

ANALOGBITS PLL LIBRARIES
M:	Paul Walmsley <paul.walmsley@sifive.com>
S:	Supported
F:	drivers/clk/analogbits/*
F:	include/linux/clk/analogbits*

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>
M:	Joel Fernandes <joel@joelfernandes.org>
M:	Christian Brauner <christian@brauner.io>
M:	Carlos Llamas <cmllamas@google.com>
M:	Suren Baghdasaryan <surenb@google.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git
F:	drivers/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:	Jiaxun Yang <jiaxun.yang@flygoat.com>
S:	Supported
F:	Documentation/devicetree/bindings/rtc/google,goldfish-rtc.txt
F:	drivers/rtc/rtc-goldfish.c

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 <william.gray@linaro.org>
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:	drivers/char/apm-emulation.c
F:	include/linux/apm_bios.h
F:	include/uapi/linux/apm_bios.h

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

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 PCIE CONTROLLER DRIVER
M:	Alyssa Rosenzweig <alyssa@rosenzweig.io>
M:	Marc Zyngier <maz@kernel.org>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	drivers/pci/controller/pcie-apple.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:	include/linux/atalk.h
F:	include/uapi/linux/atalk.h
F:	net/appletalk/

APPLIED MICRO (APM) X-GENE DEVICE TREE SUPPORT
M:	Khuong Dinh <khuong@os.amperecomputing.com>
S:	Supported
F:	arch/arm64/boot/dts/apm/

APPLIED MICRO (APM) X-GENE SOC EDAC
M:	Khuong Dinh <khuong@os.amperecomputing.com>
S:	Supported
F:	Documentation/devicetree/bindings/edac/apm-xgene-edac.txt
F:	drivers/edac/xgene_edac.c

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

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

APPLIED MICRO (APM) X-GENE SOC PMU
M:	Khuong Dinh <khuong@os.amperecomputing.com>
S:	Supported
F:	Documentation/admin-guide/perf/xgene-pmu.rst
F:	Documentation/devicetree/bindings/perf/apm-xgene-pmu.txt
F:	drivers/perf/xgene_pmu.c

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.*

AQUACOMPUTER D5 NEXT PUMP SENSOR DRIVER
M:	Aleksa Savic <savicaleksa83@gmail.com>
M:	Jack Doan <me@jackdoan.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/aquacomputer_d5next.rst
F:	drivers/hwmon/aquacomputer_d5next.c

AQUANTIA ETHERNET DRIVER (atlantic)
M:	Igor Russkikh <irusskikh@marvell.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	https://www.marvell.com/
Q:	https://patchwork.kernel.org/project/netdevbpf/list/
F:	Documentation/networking/device_drivers/ethernet/aquantia/atlantic.rst
F:	drivers/net/ethernet/aquantia/atlantic/

AQUANTIA ETHERNET DRIVER PTP SUBSYSTEM
M:	Egor Pomozov <epomozov@marvell.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.aquantia.com
F:	drivers/net/ethernet/aquantia/atlantic/aq_ptp*

AR0521 ON SEMICONDUCTOR CAMERA SENSOR DRIVER
M:	Krzysztof Hałasa <khalasa@piap.pl>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/i2c/onnn,ar0521.yaml
F:	drivers/media/i2c/ar0521.c

ARASAN NAND CONTROLLER DRIVER
M:	Miquel Raynal <miquel.raynal@bootlin.com>
M:	Naga Sureshkumar Relli <nagasure@xilinx.com>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/mtd/arasan,nand-controller.yaml
F:	drivers/mtd/nand/raw/arasan-nand-controller.c

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:	Documentation/devicetree/bindings/display/snps,arcpgu.txt
F:	drivers/gpu/drm/tiny/arcpgu.c

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 <maz@kernel.org>
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:	Documentation/devicetree/bindings/display/arm,hdlcd.yaml
F:	drivers/gpu/drm/arm/hdlcd_*

ARM INTEGRATOR, VERSATILE AND REALVIEW SUPPORT
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/arm/arm,integrator.yaml
F:	Documentation/devicetree/bindings/arm/arm,realview.yaml
F:	Documentation/devicetree/bindings/arm/arm,versatile.yaml
F:	Documentation/devicetree/bindings/arm/arm,vexpress-juno.yaml
F:	Documentation/devicetree/bindings/auxdisplay/arm,versatile-lcd.yaml
F:	Documentation/devicetree/bindings/clock/arm,syscon-icst.yaml
F:	Documentation/devicetree/bindings/i2c/arm,i2c-versatile.yaml
F:	Documentation/devicetree/bindings/interrupt-controller/arm,versatile-fpga-irq.txt
F:	Documentation/devicetree/bindings/mtd/mtd-physmap.yaml
F:	arch/arm/boot/dts/arm-realview-*
F:	arch/arm/boot/dts/integrator*
F:	arch/arm/boot/dts/versatile*
F:	arch/arm/mach-versatile/
F:	drivers/bus/arm-integrator-lm.c
F:	drivers/clk/versatile/
F:	drivers/i2c/busses/i2c-versatile.c
F:	drivers/irqchip/irq-versatile-fpga.c
F:	drivers/mtd/maps/physmap-versatile.*
F:	drivers/power/reset/arm-versatile-reboot.c
F:	drivers/soc/versatile/

ARM KOMEDA DRM-KMS DRIVER
M:	James (Qian) Wang <james.qian.wang@arm.com>
M:	Liviu Dudau <liviu.dudau@arm.com>
M:	Mihail Atanassov <mihail.atanassov@arm.com>
L:	Mali DP Maintainers <malidp@foss.arm.com>
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/arm,komeda.yaml
F:	Documentation/gpu/komeda-kms.rst
F:	drivers/gpu/drm/arm/display/include/
F:	drivers/gpu/drm/arm/display/komeda/

ARM MALI PANFROST DRM DRIVER
M:	Rob Herring <robh@kernel.org>
M:	Tomeu Vizoso <tomeu.vizoso@collabora.com>
R:	Steven Price <steven.price@arm.com>
R:	Alyssa Rosenzweig <alyssa.rosenzweig@collabora.com>
L:	dri-devel@lists.freedesktop.org
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/panfrost/
F:	include/uapi/drm/panfrost_drm.h

ARM MALI-DP DRM DRIVER
M:	Liviu Dudau <liviu.dudau@arm.com>
M:	Brian Starkey <brian.starkey@arm.com>
L:	Mali DP Maintainers <malidp@foss.arm.com>
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/arm,malidp.yaml
F:	Documentation/gpu/afbc.rst
F:	drivers/gpu/drm/arm/

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

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

ARM PORT
M:	Russell King <linux@armlinux.org.uk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Odd Fixes
W:	http://www.armlinux.org.uk/
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 PL35X NAND CONTROLLER DRIVER
M:	Miquel Raynal <miquel.raynal@bootlin.com>
M:	Naga Sureshkumar Relli <nagasure@xilinx.com>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/mtd/arm,pl353-nand-r2p1.yaml
F:	drivers/mtd/nand/raw/pl35x-nand-controller.c

ARM PRIMECELL PL35X SMC DRIVER
M:	Miquel Raynal <miquel.raynal@bootlin.com>
M:	Naga Sureshkumar Relli <nagasure@xilinx.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/memory-controllers/arm,pl353-smc.yaml
F:	drivers/memory/pl353-smc.c

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 SSP PL022 SPI DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/spi/spi-pl022.yaml
F:	drivers/spi/spi-pl022.c

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 PRIMECELL VIC PL190/PL192 DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/interrupt-controller/arm,vic.yaml
F:	drivers/irqchip/irq-vic.c

ARM SMC WATCHDOG DRIVER
M:	Julius Werner <jwerner@chromium.org>
R:	Evan Benn <evanbenn@chromium.org>
S:	Maintained
F:	Documentation/devicetree/bindings/watchdog/arm-smc-wdt.yaml
F:	drivers/watchdog/arm_smc_wdt.c

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

ARM AND ARM64 SoC SUB-ARCHITECTURES (COMMON PARTS)
M:	Arnd Bergmann <arnd@arndb.de>
M:	Olof Johansson <olof@lixom.net>
M:	soc@kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
C:	irc://irc.libera.chat/armlinux
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc.git
F:	arch/arm/boot/dts/Makefile
F:	arch/arm64/boot/dts/Makefile

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

ARM/ACTIONS SEMI ARCHITECTURE
M:	Andreas Färber <afaerber@suse.de>
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-actions@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/arm/actions.yaml
F:	Documentation/devicetree/bindings/clock/actions,owl-cmu.txt
F:	Documentation/devicetree/bindings/dma/owl-dma.yaml
F:	Documentation/devicetree/bindings/i2c/i2c-owl.yaml
F:	Documentation/devicetree/bindings/interrupt-controller/actions,owl-sirq.yaml
F:	Documentation/devicetree/bindings/mmc/owl-mmc.yaml
F:	Documentation/devicetree/bindings/net/actions,owl-emac.yaml
F:	Documentation/devicetree/bindings/pinctrl/actions,*
F:	Documentation/devicetree/bindings/power/actions,owl-sps.txt
F:	Documentation/devicetree/bindings/timer/actions,owl-timer.txt
F:	arch/arm/boot/dts/owl-*
F:	arch/arm/mach-actions/
F:	arch/arm64/boot/dts/actions/
F:	drivers/clk/actions/
F:	drivers/clocksource/timer-owl*
F:	drivers/dma/owl-dma.c
F:	drivers/i2c/busses/i2c-owl.c
F:	drivers/irqchip/irq-owl-sirq.c
F:	drivers/mmc/host/owl-mmc.c
F:	drivers/net/ethernet/actions/
F:	drivers/pinctrl/actions/*
F:	drivers/soc/actions/
F:	include/dt-bindings/power/owl-*
F:	include/dt-bindings/reset/actions,*
F:	include/linux/soc/actions/
N:	owl

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:	Chen-Yu Tsai <wens@csie.org>
M:	Jernej Skrabec <jernej.skrabec@gmail.com>
M:	Samuel Holland <samuel@sholland.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sunxi/linux.git
L:	linux-sunxi@lists.linux.dev
F:	arch/arm/mach-sunxi/
F:	arch/arm64/boot/dts/allwinner/
F:	drivers/clk/sunxi-ng/
F:	drivers/pinctrl/sunxi/
F:	drivers/soc/sunxi/
N:	allwinner
N:	sun[x456789]i
N:	sun50i

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:	Documentation/devicetree/bindings/clock/amlogic*
F:	drivers/clk/meson/
F:	include/dt-bindings/clock/gxbb*
F:	include/dt-bindings/clock/meson*

ARM/Amlogic Meson SoC Crypto Drivers
M:	Corentin Labbe <clabbe@baylibre.com>
L:	linux-crypto@vger.kernel.org
L:	linux-amlogic@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/crypto/amlogic*
F:	drivers/crypto/amlogic/

ARM/Amlogic Meson SoC Sound Drivers
M:	Jerome Brunet <jbrunet@baylibre.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/sound/amlogic*
F:	sound/soc/meson/

ARM/Amlogic Meson SoC support
M:	Neil Armstrong <narmstrong@baylibre.com>
M:	Kevin Hilman <khilman@baylibre.com>
R:	Jerome Brunet <jbrunet@baylibre.com>
R:	Martin Blumenstingl <martin.blumenstingl@googlemail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-amlogic@lists.infradead.org
S:	Maintained
W:	http://linux-meson.com/
F:	arch/arm/boot/dts/meson*
F:	arch/arm/mach-meson/
F:	arch/arm64/boot/dts/amlogic/
F:	drivers/mmc/host/meson*
F:	drivers/pinctrl/meson/
F:	drivers/rtc/rtc-meson*
F:	drivers/soc/amlogic/
N:	meson

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

ARM/APPLE MACHINE SUPPORT
M:	Hector Martin <marcan@marcan.st>
M:	Sven Peter <sven@svenpeter.dev>
R:	Alyssa Rosenzweig <alyssa@rosenzweig.io>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
W:	https://asahilinux.org
B:	https://github.com/AsahiLinux/linux/issues
C:	irc://irc.oftc.net/asahi-dev
T:	git https://github.com/AsahiLinux/linux.git
F:	Documentation/devicetree/bindings/arm/apple.yaml
F:	Documentation/devicetree/bindings/arm/apple/*
F:	Documentation/devicetree/bindings/clock/apple,nco.yaml
F:	Documentation/devicetree/bindings/dma/apple,admac.yaml
F:	Documentation/devicetree/bindings/i2c/apple,i2c.yaml
F:	Documentation/devicetree/bindings/interrupt-controller/apple,*
F:	Documentation/devicetree/bindings/iommu/apple,dart.yaml
F:	Documentation/devicetree/bindings/iommu/apple,sart.yaml
F:	Documentation/devicetree/bindings/mailbox/apple,mailbox.yaml
F:	Documentation/devicetree/bindings/nvme/apple,nvme-ans.yaml
F:	Documentation/devicetree/bindings/nvmem/apple,efuses.yaml
F:	Documentation/devicetree/bindings/pci/apple,pcie.yaml
F:	Documentation/devicetree/bindings/pinctrl/apple,pinctrl.yaml
F:	Documentation/devicetree/bindings/power/apple*
F:	Documentation/devicetree/bindings/watchdog/apple,wdt.yaml
F:	arch/arm64/boot/dts/apple/
F:	drivers/clk/clk-apple-nco.c
F:	drivers/dma/apple-admac.c
F:	drivers/i2c/busses/i2c-pasemi-core.c
F:	drivers/i2c/busses/i2c-pasemi-platform.c
F:	drivers/iommu/apple-dart.c
F:	drivers/irqchip/irq-apple-aic.c
F:	drivers/mailbox/apple-mailbox.c
F:	drivers/nvme/host/apple.c
F:	drivers/nvmem/apple-efuses.c
F:	drivers/pinctrl/pinctrl-apple-gpio.c
F:	drivers/soc/apple/*
F:	drivers/watchdog/apple_wdt.c
F:	include/dt-bindings/interrupt-controller/apple-aic.h
F:	include/dt-bindings/pinctrl/apple.h
F:	include/linux/apple-mailbox.h
F:	include/linux/soc/apple/*

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

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:	Documentation/devicetree/bindings/i2c/aspeed,i2c.yaml
F:	Documentation/devicetree/bindings/interrupt-controller/aspeed,ast2400-i2c-ic.txt
F:	drivers/i2c/busses/i2c-aspeed.c
F:	drivers/irqchip/irq-aspeed-i2c-ic.c

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)
S:	Supported
Q:	https://patchwork.ozlabs.org/project/linux-aspeed/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/joel/aspeed.git
F:	Documentation/devicetree/bindings/arm/aspeed/
F:	arch/arm/boot/dts/aspeed-*
F:	arch/arm/mach-aspeed/
N:	aspeed

ARM/BITMAIN ARCHITECTURE
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/arm/bitmain.yaml
F:	Documentation/devicetree/bindings/clock/bitmain,bm1880-clk.yaml
F:	Documentation/devicetree/bindings/pinctrl/bitmain,bm1880-pinctrl.txt
F:	arch/arm64/boot/dts/bitmain/
F:	drivers/clk/clk-bm1880.c
F:	drivers/pinctrl/pinctrl-bm1880.c

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

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@marvell.com>
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/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>
M:	Suzuki K Poulose <suzuki.poulose@arm.com>
R:	Mike Leach <mike.leach@linaro.org>
R:	Leo Yan <leo.yan@linaro.org>
L:	coresight@lists.linaro.org (moderated for non-subscribers)
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/coresight/linux.git
F:	Documentation/ABI/testing/sysfs-bus-coresight-devices-*
F:	Documentation/devicetree/bindings/arm/arm,coresight-*.yaml
F:	Documentation/devicetree/bindings/arm/arm,embedded-trace-extension.yaml
F:	Documentation/devicetree/bindings/arm/arm,trace-buffer-extension.yaml
F:	Documentation/trace/coresight/*
F:	drivers/hwtracing/coresight/*
F:	include/dt-bindings/arm/coresight-cti-dt.h
F:	include/linux/coresight*
F:	samples/coresight/*
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/arch/arm/util/pmu.c
F:	tools/perf/util/cs-etm-decoder/*
F:	tools/perf/util/cs-etm.*

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)
S:	Maintained
T:	git git://github.com/ulli-kroll/linux.git
F:	Documentation/devicetree/bindings/arm/gemini.yaml
F:	Documentation/devicetree/bindings/net/cortina,gemini-ethernet.yaml
F:	Documentation/devicetree/bindings/pinctrl/cortina,gemini-pinctrl.txt
F:	Documentation/devicetree/bindings/rtc/faraday,ftrtc010.yaml
F:	arch/arm/boot/dts/gemini*
F:	arch/arm/mach-gemini/
F:	drivers/crypto/gemini/
F:	drivers/net/ethernet/cortina/
F:	drivers/pinctrl/pinctrl-gemini.c
F:	drivers/rtc/rtc-ftrtc010.c

ARM/CZ.NIC TURRIS SUPPORT
M:	Marek Behún <kabel@kernel.org>
S:	Maintained
W:	https://www.turris.cz/
F:	Documentation/ABI/testing/debugfs-moxtet
F:	Documentation/ABI/testing/sysfs-bus-moxtet-devices
F:	Documentation/ABI/testing/sysfs-firmware-turris-mox-rwtm
F:	Documentation/devicetree/bindings/bus/moxtet.txt
F:	Documentation/devicetree/bindings/firmware/cznic,turris-mox-rwtm.txt
F:	Documentation/devicetree/bindings/gpio/gpio-moxtet.txt
F:	Documentation/devicetree/bindings/leds/cznic,turris-omnia-leds.yaml
F:	Documentation/devicetree/bindings/watchdog/armada-37xx-wdt.txt
F:	drivers/bus/moxtet.c
F:	drivers/firmware/turris-mox-rwtm.c
F:	drivers/leds/leds-turris-omnia.c
F:	drivers/mailbox/armada-37xx-rwtm-mailbox.c
F:	drivers/gpio/gpio-moxtet.c
F:	drivers/watchdog/armada_37xx_wdt.c
F:	include/dt-bindings/bus/moxtet.h
F:	include/linux/armada-37xx-rwtm-mailbox.h
F:	include/linux/moxtet.h

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)
S:	Maintained
W:	http://www.armlinux.org.uk/
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 <festevam@gmail.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
X:	drivers/media/i2c/
N:	imx
N:	mxs

ARM/FREESCALE LAYERSCAPE ARM ARCHITECTURE
M:	Shawn Guo <shawnguo@kernel.org>
M:	Li Yang <leoyang.li@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/boot/dts/ls1021a*
F:	arch/arm64/boot/dts/freescale/fsl-*
F:	arch/arm64/boot/dts/freescale/qoriq-*

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/boot/dts/vf*
F:	arch/arm/mach-imx/*vf610*

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)
S:	Supported
W:	http://www.hisilicon.com
T:	git git://github.com/hisilicon/linux-hisi.git
F:	arch/arm/boot/dts/hi3*
F:	arch/arm/boot/dts/hip*
F:	arch/arm/boot/dts/hisi*
F:	arch/arm/mach-hisi/
F:	arch/arm64/boot/dts/hisilicon/

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

ARM/HPE GXP ARCHITECTURE
M:	Jean-Marie Verdun <verdun@hpe.com>
M:	Nick Hawkins <nick.hawkins@hpe.com>
S:	Maintained
F:	Documentation/devicetree/bindings/arm/hpe,gxp.yaml
F:	Documentation/devicetree/bindings/spi/hpe,gxp-spi.yaml
F:	Documentation/devicetree/bindings/timer/hpe,gxp-timer.yaml
F:	arch/arm/boot/dts/hpe-bmc*
F:	arch/arm/boot/dts/hpe-gxp*
F:	arch/arm/mach-hpe/
F:	drivers/clocksource/timer-gxp.c
F:	drivers/spi/spi-gxp.c
F:	drivers/watchdog/gxp-wdt.c

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

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:	Linus Walleij <linusw@kernel.org>
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:	Documentation/devicetree/bindings/arm/intel-ixp4xx.yaml
F:	Documentation/devicetree/bindings/bus/intel,ixp4xx-expansion-bus-controller.yaml
F:	Documentation/devicetree/bindings/gpio/intel,ixp4xx-gpio.txt
F:	Documentation/devicetree/bindings/interrupt-controller/intel,ixp4xx-interrupt.yaml
F:	Documentation/devicetree/bindings/timer/intel,ixp4xx-timer.yaml
F:	arch/arm/mach-ixp4xx/
F:	drivers/bus/intel-ixp4xx-eb.c
F:	drivers/clocksource/timer-ixp4xx.c
F:	drivers/crypto/ixp4xx_crypto.c
F:	drivers/gpio/gpio-ixp4xx.c
F:	drivers/irqchip/irq-ixp4xx.c
F:	include/linux/irqchip/irq-ixp4xx.h
F:	include/linux/platform_data/timer-ixp4xx.h

ARM/INTEL KEEMBAY ARCHITECTURE
M:	Paul J. Murphy <paul.j.murphy@intel.com>
M:	Daniele Alessandrelli <daniele.alessandrelli@intel.com>
S:	Maintained
F:	Documentation/devicetree/bindings/arm/intel,keembay.yaml
F:	arch/arm64/boot/dts/intel/keembay-evm.dts
F:	arch/arm64/boot/dts/intel/keembay-soc.dtsi

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:	Vladimir Zapolskiy <vz@mleia.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-lpc2k.txt
F:	arch/arm/boot/dts/lpc43*
F:	drivers/i2c/busses/i2c-lpc2k.c
F:	drivers/memory/pl172.c
F:	drivers/mtd/spi-nor/controllers/nxp-spifi.c
F:	drivers/rtc/rtc-lpc24xx.c
N:	lpc18xx

ARM/LPC32XX SOC SUPPORT
M:	Vladimir Zapolskiy <vz@mleia.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://github.com/vzapolskiy/linux-lpc32xx.git
F:	Documentation/devicetree/bindings/i2c/i2c-pnx.txt
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:	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
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gclement/mvebu.git
F:	Documentation/devicetree/bindings/soc/dove/
F:	arch/arm/boot/dts/dove*
F:	arch/arm/boot/dts/orion5x*
F:	arch/arm/mach-dove/
F:	arch/arm/mach-mv78xx0/
F:	arch/arm/mach-orion5x/
F:	arch/arm/plat-orion/
F:	drivers/soc/dove/

ARM/Marvell Kirkwood and Armada 370, 375, 38x, 39x, XP, 3700, 7K/8K, CN9130 SOC support
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
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gclement/mvebu.git
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:	arch/arm64/boot/dts/marvell/cn913*
F:	drivers/cpufreq/armada-37xx-cpufreq.c
F:	drivers/cpufreq/armada-8k-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-mt2712.txt
F:	Documentation/devicetree/bindings/rtc/rtc-mt7622.txt
F:	drivers/rtc/rtc-mt2712.c
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
W:	https://mtk.wiki.kernel.org/
C:	irc://chat.freenode.net/linux-mediatek
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/
F:	drivers/soc/mediatek/
N:	mtk
N:	mt[678]
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:	Documentation/devicetree/bindings/phy/mediatek,*
F:	drivers/phy/mediatek/

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

ARM/Microchip Sparx5 SoC support
M:	Lars Povlsen <lars.povlsen@microchip.com>
M:	Steen Hegelund <Steen.Hegelund@microchip.com>
M:	UNGLinuxDriver@microchip.com
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
T:	git git://github.com/microchip-ung/linux-upstream.git
F:	arch/arm64/boot/dts/microchip/
F:	drivers/pinctrl/pinctrl-microchip-sgpio.c
N:	sparx5

Microchip Timer Counter Block (TCB) Capture Driver
M:	Kamel Bouhara <kamel.bouhara@bootlin.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	drivers/counter/microchip-tcb-capture.c

ARM/MILBEAUT ARCHITECTURE
M:	Taichi Sugaya <sugaya.taichi@socionext.com>
M:	Takao Orito <orito.takao@socionext.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/boot/dts/milbeaut*
F:	arch/arm/mach-milbeaut/
N:	milbeaut

ARM/MIOA701 MACHINE SUPPORT
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/mioa701.c

ARM/MStar/Sigmastar Armv7 SoC support
M:	Daniel Palmer <daniel@thingy.jp>
M:	Romain Perier <romain.perier@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
W:	http://linux-chenxing.org/
T:	git git://github.com/linux-chenxing/linux.git
F:	Documentation/devicetree/bindings/arm/mstar/*
F:	Documentation/devicetree/bindings/clock/mstar,msc313-mpll.yaml
F:	Documentation/devicetree/bindings/gpio/mstar,msc313-gpio.yaml
F:	arch/arm/boot/dts/mstar-*
F:	arch/arm/mach-mstar/
F:	drivers/clk/mstar/
F:	drivers/clocksource/timer-msc313e.c
F:	drivers/gpio/gpio-msc313.c
F:	drivers/rtc/rtc-msc313.c
F:	drivers/watchdog/msc313e_wdt.c
F:	include/dt-bindings/clock/mstar-*
F:	include/dt-bindings/gpio/msc313-gpio.h

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

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

ARM/NUVOTON NPCM ARCHITECTURE
M:	Avi Fishman <avifishman70@gmail.com>
M:	Tomer Maimon <tmaimon77@gmail.com>
M:	Tali Perry <tali.perry1@gmail.com>
R:	Patrick Venture <venture@google.com>
R:	Nancy Yuen <yuenn@google.com>
R:	Benjamin Fair <benjaminfair@google.com>
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/*/*/*npcm*
F:	Documentation/devicetree/bindings/*/*npcm*
F:	Documentation/devicetree/bindings/arm/npcm/*
F:	arch/arm/boot/dts/nuvoton-npcm*
F:	arch/arm/mach-npcm/
F:	arch/arm64/boot/dts/nuvoton/
F:	drivers/*/*npcm*
F:	drivers/*/*/*npcm*
F:	include/dt-bindings/clock/nuvoton,npcm7xx-clock.h
F:	include/dt-bindings/clock/nuvoton,npcm845-clk.h

ARM/NUVOTON WPCM450 ARCHITECTURE
M:	Jonathan Neuschäfer <j.neuschaefer@gmx.net>
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
S:	Maintained
W:	https://github.com/neuschaefer/wpcm450/wiki
F:	Documentation/devicetree/bindings/*/*wpcm*
F:	arch/arm/boot/dts/nuvoton-wpcm450*
F:	arch/arm/mach-npcm/wpcm450.c
F:	drivers/*/*/*wpcm*
F:	drivers/*/*wpcm*

ARM/NXP S32G ARCHITECTURE
M:	Chester Lin <clin@suse.com>
R:	Andreas Färber <afaerber@suse.de>
R:	Matthias Brugger <mbrugger@suse.com>
R:	NXP S32 Linux Team <s32@nxp.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm64/boot/dts/freescale/s32g*.dts*

ARM/OPENMOKO NEO FREERUNNER (GTA02) MACHINE SUPPORT
L:	openmoko-kernel@lists.openmoko.org (subscribers-only)
S:	Orphan
W:	http://wiki.openmoko.org/wiki/Neo_FreeRunner
F:	arch/arm/mach-s3c/gta02.h
F:	arch/arm/mach-s3c/mach-gta02.c

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)
S:	Maintained
W:	http://www.digriz.org.uk/ts78xx/kernel
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/boot/dts/ox8*.dts*
F:	arch/arm/mach-oxnas/
F:	drivers/power/reset/oxnas-restart.c
N:	oxnas

ARM/PALM TREO SUPPORT
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Orphan
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 (moderated for non-subscribers)
S:	Maintained
W:	http://hackndev.com
F:	arch/arm/mach-pxa/include/mach/palmld.h
F:	arch/arm/mach-pxa/include/mach/palmtc.h
F:	arch/arm/mach-pxa/include/mach/palmtx.h
F:	arch/arm/mach-pxa/palmld.c
F:	arch/arm/mach-pxa/palmt5.*
F:	arch/arm/mach-pxa/palmtc.c
F:	arch/arm/mach-pxa/palmte2.*
F:	arch/arm/mach-pxa/palmtx.c

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

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

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

ARM/QUALCOMM SUPPORT
M:	Andy Gross <agross@kernel.org>
M:	Bjorn Andersson <bjorn.andersson@linaro.org>
R:	Konrad Dybcio <konrad.dybcio@somainline.org>
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/qcom/linux.git
F:	Documentation/devicetree/bindings/*/qcom*
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/*/*/qcom*
F:	drivers/*/*/qcom/
F:	drivers/*/pm8???-*
F:	drivers/*/qcom*
F:	drivers/*/qcom/
F:	drivers/bluetooth/btqcomsmd.c
F:	drivers/clocksource/timer-qcom.c
F:	drivers/cpuidle/cpuidle-qcom-spm.c
F:	drivers/extcon/extcon-qcom*
F:	drivers/i2c/busses/i2c-qcom-geni.c
F:	drivers/i2c/busses/i2c-qup.c
F:	drivers/iommu/msm*
F:	drivers/mfd/ssbi.c
F:	drivers/mmc/host/mmci_qcom*
F:	drivers/mmc/host/sdhci-msm.c
F:	drivers/pci/controller/dwc/pcie-qcom.c
F:	drivers/phy/qualcomm/
F:	drivers/power/*/msm*
F:	drivers/reset/reset-qcom-*
F:	drivers/ufs/host/ufs-qcom*
F:	drivers/spi/spi-geni-qcom.c
F:	drivers/spi/spi-qcom-qspi.c
F:	drivers/spi/spi-qup.c
F:	drivers/tty/serial/msm_serial.c
F:	drivers/usb/dwc3/dwc3-qcom.c
F:	include/dt-bindings/*/qcom*
F:	include/linux/*/qcom*
F:	include/linux/soc/qcom/

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/RDA MICRO ARCHITECTURE
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-unisoc@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/arm/rda.yaml
F:	Documentation/devicetree/bindings/gpio/gpio-rda.yaml
F:	Documentation/devicetree/bindings/interrupt-controller/rda,8810pl-intc.yaml
F:	Documentation/devicetree/bindings/serial/rda,8810pl-uart.yaml
F:	Documentation/devicetree/bindings/timer/rda,8810pl-timer.yaml
F:	arch/arm/boot/dts/rda8810pl-*
F:	drivers/clocksource/timer-rda.c
F:	drivers/gpio/gpio-rda.c
F:	drivers/irqchip/irq-rda-intc.c
F:	drivers/tty/serial/rda-uart.c

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

ARM/RENESAS ARM64 ARCHITECTURE
M:	Geert Uytterhoeven <geert+renesas@glider.be>
M:	Magnus Damm <magnus.damm@gmail.com>
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
Q:	http://patchwork.kernel.org/project/linux-renesas-soc/list/
C:	irc://irc.libera.chat/renesas-soc
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-devel.git next
F:	Documentation/devicetree/bindings/arm/renesas.yaml
F:	Documentation/devicetree/bindings/hwinfo/renesas,prr.yaml
F:	Documentation/devicetree/bindings/soc/renesas/
F:	arch/arm64/boot/dts/renesas/
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)
S:	Maintained
W:	http://www.armlinux.org.uk/
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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mmind/linux-rockchip.git
F:	Documentation/devicetree/bindings/i2c/i2c-rk3x.yaml
F:	Documentation/devicetree/bindings/mmc/rockchip-dw-mshc.yaml
F:	Documentation/devicetree/bindings/spi/spi-rockchip.yaml
F:	arch/arm/boot/dts/rk3*
F:	arch/arm/boot/dts/rv1108*
F:	arch/arm/mach-rockchip/
F:	drivers/*/*/*rockchip*
F:	drivers/*/*rockchip*
F:	drivers/clk/rockchip/
F:	drivers/i2c/busses/i2c-rk3x.c
F:	sound/soc/rockchip/
N:	rockchip

ARM/SAMSUNG S3C, S5P AND EXYNOS ARM ARCHITECTURES
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
R:	Alim Akhtar <alim.akhtar@samsung.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
C:	irc://irc.libera.chat/linux-exynos
Q:	https://patchwork.kernel.org/project/linux-samsung-soc/list/
B:	mailto:linux-samsung-soc@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/krzk/linux.git
F:	Documentation/arm/samsung/
F:	Documentation/devicetree/bindings/arm/samsung/
F:	Documentation/devicetree/bindings/hwinfo/samsung,*
F:	Documentation/devicetree/bindings/power/pd-samsung.yaml
F:	Documentation/devicetree/bindings/soc/samsung/
F:	arch/arm/boot/dts/exynos*
F:	arch/arm/boot/dts/s3c*
F:	arch/arm/boot/dts/s5p*
F:	arch/arm/mach-exynos*/
F:	arch/arm/mach-s3c/
F:	arch/arm/mach-s5p*/
F:	arch/arm64/boot/dts/exynos/
F:	drivers/*/*/*s3c24*
F:	drivers/*/*s3c24*
F:	drivers/*/*s3c64xx*
F:	drivers/*/*s5pv210*
F:	drivers/clocksource/samsung_pwm_timer.c
F:	drivers/memory/samsung/
F:	drivers/pwm/pwm-samsung.c
F:	drivers/soc/samsung/
F:	drivers/tty/serial/samsung*
F:	include/clocksource/samsung_pwm.h
F:	include/linux/platform_data/*s3c*
F:	include/linux/serial_s3c.h
F:	include/linux/soc/samsung/
N:	exynos
N:	s3c2410
N:	s3c64xx
N:	s5pv210

ARM/SAMSUNG S5P SERIES 2D GRAPHICS ACCELERATION (G2D) SUPPORT
M:	Łukasz Stelmach <l.stelmach@samsung.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/platform/samsung/s5p-g2d/

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

ARM/SAMSUNG S5P SERIES JPEG CODEC SUPPORT
M:	Andrzej Pietrasiewicz <andrzejtp2010@gmail.com>
M:	Jacek Anaszewski <jacek.anaszewski@gmail.com>
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/samsung,s5pv210-jpeg.yaml
F:	drivers/media/platform/samsung/s5p-jpeg/

ARM/SAMSUNG S5P SERIES Multi Format Codec (MFC) SUPPORT
M:	Marek Szyprowski <m.szyprowski@samsung.com>
M:	Andrzej Hajda <andrzej.hajda@intel.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/platform/samsung/s5p-mfc/

ARM/SHMOBILE ARM ARCHITECTURE
M:	Geert Uytterhoeven <geert+renesas@glider.be>
M:	Magnus Damm <magnus.damm@gmail.com>
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
Q:	http://patchwork.kernel.org/project/linux-renesas-soc/list/
C:	irc://irc.libera.chat/renesas-soc
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-devel.git next
F:	Documentation/devicetree/bindings/arm/renesas.yaml
F:	Documentation/devicetree/bindings/soc/renesas/
F:	arch/arm/boot/dts/emev2*
F:	arch/arm/boot/dts/gr-peach*
F:	arch/arm/boot/dts/iwg20d-q7*
F:	arch/arm/boot/dts/r7s*
F:	arch/arm/boot/dts/r8a*
F:	arch/arm/boot/dts/r9a*
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:	drivers/soc/renesas/
F:	include/linux/soc/renesas/

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

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

ARM/SOCFPGA EDAC SUPPORT
M:	Dinh Nguyen <dinguyen@kernel.org>
S:	Maintained
F:	drivers/edac/altera_edac.[ch]

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

ARM/STI ARCHITECTURE
M:	Patrice Chotard <patrice.chotard@foss.st.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
W:	http://www.stlinux.com
F:	Documentation/devicetree/bindings/i2c/i2c-st.txt
F:	arch/arm/boot/dts/sti*
F:	arch/arm/mach-sti/
F:	drivers/ata/ahci_st.c
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/platform/st/sti/c8sectpfe/
F:	drivers/media/rc/st_rc.c
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:	include/linux/remoteproc/st_slim_rproc.h

ARM/STM32 ARCHITECTURE
M:	Maxime Coquelin <mcoquelin.stm32@gmail.com>
M:	Alexandre Torgue <alexandre.torgue@foss.st.com>
L:	linux-stm32@st-md-mailman.stormreply.com (moderated for non-subscribers)
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
F:	arch/arm/boot/dts/stm32*
F:	arch/arm/mach-stm32/
F:	drivers/clocksource/armv7m_systick.c
N:	stm32
N:	stm

ARM/SUNPLUS SP7021 SOC SUPPORT
M:	Qin Jian <qinjian@cqplus1.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for mon-subscribers)
S:	Maintained
W:	https://sunplus-tibbo.atlassian.net/wiki/spaces/doc/overview
F:	Documentation/devicetree/bindings/arm/sunplus,sp7021.yaml
F:	Documentation/devicetree/bindings/clock/sunplus,sp7021-clkc.yaml
F:	Documentation/devicetree/bindings/interrupt-controller/sunplus,sp7021-intc.yaml
F:	Documentation/devicetree/bindings/reset/sunplus,reset.yaml
F:	arch/arm/boot/dts/sunplus-sp7021*.dts*
F:	arch/arm/configs/sp7021_*defconfig
F:	arch/arm/mach-sunplus/
F:	drivers/irqchip/irq-sp7021-intc.c
F:	drivers/reset/reset-sunplus.c
F:	include/dt-bindings/clock/sunplus,sp7021-clkc.h
F:	include/dt-bindings/reset/sunplus,sp7021-reset.h

ARM/Synaptics SoC support
M:	Jisheng Zhang <jszhang@kernel.org>
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/berlin*
F:	arch/arm/mach-berlin/
F:	arch/arm64/boot/dts/synaptics/

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 <hverkuil-cisco@xs4all.nl>
L:	linux-tegra@vger.kernel.org
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/tegra-cec.txt
F:	drivers/media/cec/platform/tegra/

ARM/TESLA FSD SoC SUPPORT
M:	Alim Akhtar <alim.akhtar@samsung.com>
M:	linux-fsd@tesla.com
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
F:	arch/arm64/boot/dts/tesla*

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:	Nishanth Menon <nm@ti.com>
M:	Santosh Shilimkar <ssantosh@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ti/linux.git
F:	arch/arm/boot/dts/keystone-*
F:	arch/arm/mach-keystone/

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/TEXAS INSTRUMENTS K3 ARCHITECTURE
M:	Nishanth Menon <nm@ti.com>
M:	Vignesh Raghavendra <vigneshr@ti.com>
M:	Tero Kristo <kristo@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/arm/ti/k3.yaml
F:	Documentation/devicetree/bindings/hwinfo/ti,k3-socinfo.yaml
F:	arch/arm64/boot/dts/ti/Makefile
F:	arch/arm64/boot/dts/ti/k3-*
F:	include/dt-bindings/pinctrl/k3.h

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/TOSHIBA VISCONTI ARCHITECTURE
M:	Nobuhiro Iwamatsu <nobuhiro1.iwamatsu@toshiba.co.jp>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/iwamatsu/linux-visconti.git
F:	Documentation/devicetree/bindings/arm/toshiba.yaml
F:	Documentation/devicetree/bindings/clock/toshiba,tmpv770x-pipllct.yaml
F:	Documentation/devicetree/bindings/clock/toshiba,tmpv770x-pismu.yaml
F:	Documentation/devicetree/bindings/net/toshiba,visconti-dwmac.yaml
F:	Documentation/devicetree/bindings/gpio/toshiba,gpio-visconti.yaml
F:	Documentation/devicetree/bindings/pci/toshiba,visconti-pcie.yaml
F:	Documentation/devicetree/bindings/pinctrl/toshiba,visconti-pinctrl.yaml
F:	Documentation/devicetree/bindings/watchdog/toshiba,visconti-wdt.yaml
F:	arch/arm64/boot/dts/toshiba/
F:	drivers/clk/visconti/
F:	drivers/net/ethernet/stmicro/stmmac/dwmac-visconti.c
F:	drivers/gpio/gpio-visconti.c
F:	drivers/pci/controller/dwc/pcie-visconti.c
F:	drivers/pinctrl/visconti/
F:	drivers/watchdog/visconti_wdt.c
N:	visconti

ARM/UNIPHIER ARCHITECTURE
M:	Kunihiko Hayashi <hayashi.kunihiko@socionext.com>
M:	Masami Hiramatsu <mhiramat@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/arm/socionext/uniphier.yaml
F:	Documentation/devicetree/bindings/gpio/socionext,uniphier-gpio.yaml
F:	Documentation/devicetree/bindings/pinctrl/socionext,uniphier-pinctrl.yaml
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/dma/uniphier-mdmac.c
F:	drivers/gpio/gpio-uniphier.c
F:	drivers/i2c/busses/i2c-uniphier*
F:	drivers/irqchip/irq-uniphier-aidet.c
F:	drivers/mmc/host/uniphier-sd.c
F:	drivers/pinctrl/uniphier/
F:	drivers/reset/reset-uniphier.c
F:	drivers/tty/serial/8250/8250_uniphier.c
N:	uniphier

ARM/VERSATILE EXPRESS PLATFORM
M:	Liviu Dudau <liviu.dudau@arm.com>
M:	Sudeep Holla <sudeep.holla@arm.com>
M:	Lorenzo Pieralisi <lpieralisi@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	*/*/*/vexpress*
F:	*/*/vexpress*
F:	arch/arm/boot/dts/vexpress*
F:	arch/arm/mach-vexpress/
F:	arch/arm64/boot/dts/arm/
F:	drivers/clk/versatile/clk-vexpress-osc.c
F:	drivers/clocksource/timer-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)
S:	Maintained
W:	http://www.armlinux.org.uk/
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/include/mach/vpac270.h
F:	arch/arm/mach-pxa/vpac270.c

ARM/VT8500 ARM ARCHITECTURE
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Orphan
F:	Documentation/devicetree/bindings/i2c/i2c-wmt.txt
F:	arch/arm/mach-vt8500/
F:	drivers/clocksource/timer-vt8500.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/include/mach/z2.h
F:	arch/arm/mach-pxa/z2.c

ARM/ZYNQ ARCHITECTURE
M:	Michal Simek <michal.simek@xilinx.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
W:	http://wiki.xilinx.com
T:	git https://github.com/Xilinx/linux-xlnx.git
F:	Documentation/devicetree/bindings/i2c/cdns,i2c-r1p10.yaml
F:	Documentation/devicetree/bindings/i2c/xlnx,xps-iic-2.00.a.yaml
F:	Documentation/devicetree/bindings/spi/xlnx,zynq-qspi.yaml
F:	arch/arm/mach-zynq/
F:	drivers/clocksource/timer-cadence-ttc.c
F:	drivers/cpuidle/cpuidle-zynq.c
F:	drivers/edac/synopsys_edac.c
F:	drivers/i2c/busses/i2c-cadence.c
F:	drivers/i2c/busses/i2c-xiic.c
F:	drivers/mmc/host/sdhci-of-arasan.c
N:	zynq
N:	xilinx

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

ARROW SPEEDCHIPS XRS7000 SERIES ETHERNET SWITCH DRIVER
M:	George McCollister <george.mccollister@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/dsa/arrow,xrs700x.yaml
F:	drivers/net/dsa/xrs700x/*
F:	net/dsa/tag_xrs700x.c

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

ASAHI KASEI AK7375 LENS VOICE COIL DRIVER
M:	Tianshu Qiu <tian.shu.qiu@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ak7375.txt
F:	drivers/media/i2c/ak7375.c

ASAHI KASEI AK8974 DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	http://www.akm.com/
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.rst
F:	drivers/hwmon/asc7621.c

ASIX AX88796C SPI ETHERNET ADAPTER
M:	Łukasz Stelmach <l.stelmach@samsung.com>
S:	Maintained
F:	Documentation/devicetree/bindings/net/asix,ax88796c.yaml
F:	drivers/net/ethernet/asix/ax88796c_*

ASPEED PECI CONTROLLER
M:	Iwona Winiarska <iwona.winiarska@intel.com>
L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/peci/peci-aspeed.yaml
F:	drivers/peci/controller/peci-aspeed.c

ASPEED PINCTRL DRIVERS
M:	Andrew Jeffery <andrew@aj.id.au>
L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pinctrl/aspeed,*
F:	drivers/pinctrl/aspeed/

ASPEED SCU INTERRUPT CONTROLLER DRIVER
M:	Eddie James <eajames@linux.ibm.com>
L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/interrupt-controller/aspeed,ast2xxx-scu-ic.txt
F:	drivers/irqchip/irq-aspeed-scu-ic.c
F:	include/dt-bindings/interrupt-controller/aspeed-scu-ic.h

ASPEED SD/MMC DRIVER
M:	Andrew Jeffery <andrew@aj.id.au>
L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
L:	linux-mmc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/mmc/aspeed,sdhci.yaml
F:	drivers/mmc/host/sdhci-of-aspeed*

ASPEED SMC SPI DRIVER
M:	Chin-Ting Kuo <chin-ting_kuo@aspeedtech.com>
M:	Cédric Le Goater <clg@kaod.org>
L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
L:	linux-spi@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/spi/aspeed,ast2600-fmc.yaml
F:	drivers/spi/spi-aspeed-smc.c

ASPEED VIDEO ENGINE DRIVER
M:	Eddie James <eajames@linux.ibm.com>
L:	linux-media@vger.kernel.org
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/media/aspeed-video.txt
F:	drivers/media/platform/aspeed/

ASPEED USB UDC DRIVER
M:	Neal Liu <neal_liu@aspeedtech.com>
L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/usb/aspeed,ast2600-udc.yaml
F:	drivers/usb/gadget/udc/aspeed_udc.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
S:	Maintained
W:	http://acpi4asus.sf.net
F:	drivers/platform/x86/asus*.c
F:	drivers/platform/x86/eeepc*.c

ASUS TF103C DOCK DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pdx86/platform-drivers-x86.git
F:	drivers/platform/x86/asus-tf103c-dock.c

ASUS WMI HARDWARE MONITOR DRIVER
M:	Ed Brindley <kernel@maidavale.org>
M:	Denis Pauk <pauk.denis@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/asus_wmi_sensors.c

ASUS WMI EC HARDWARE MONITOR DRIVER
M:	Eugene Shalygin <eugene.shalygin@gmail.com>
M:	Denis Pauk <pauk.denis@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/asus_wmi_ec_sensors.c

ASUS EC HARDWARE MONITOR DRIVER
M:	Eugene Shalygin <eugene.shalygin@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/asus-ec-sensors.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.rst
F:	crypto/asymmetric_keys/
F:	include/crypto/pkcs7.h
F:	include/crypto/public_key.h
F:	include/linux/verification.h

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

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

ATA OVER ETHERNET (AOE) DRIVER
M:	"Justin Sanders" <justin@coraid.com>
S:	Supported
W:	http://www.openaoe.org/
F:	Documentation/admin-guide/aoe/
F:	drivers/block/aoe/

ATC260X PMIC MFD DRIVER
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
M:	Cristian Ciocaltea <cristian.ciocaltea@gmail.com>
L:	linux-actions@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/mfd/actions,atc260x.yaml
F:	drivers/input/misc/atc260x-onkey.c
F:	drivers/mfd/atc260*
F:	drivers/power/reset/atc260x-poweroff.c
F:	drivers/regulator/atc260x-regulator.c
F:	include/linux/mfd/atc260x/*

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

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

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

ATHEROS ATH5K WIRELESS DRIVER
M:	Jiri Slaby <jirislaby@kernel.org>
M:	Nick Kossifidis <mickflemm@gmail.com>
M:	Luis Chamberlain <mcgrof@kernel.org>
L:	linux-wireless@vger.kernel.org
S:	Maintained
W:	https://wireless.wiki.kernel.org/en/users/Drivers/ath5k
F:	drivers/net/wireless/ath/ath5k/

ATHEROS ATH6KL WIRELESS DRIVER
L:	linux-wireless@vger.kernel.org
S:	Orphan
W:	https://wireless.wiki.kernel.org/en/users/Drivers/ath6kl
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:	Chris Snook <chris.snook@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
W:	http://sourceforge.net/projects/atl1
W:	http://atl1.sourceforge.net
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
S:	Maintained
W:	http://linux-atm.sourceforge.net
F:	drivers/atm/
F:	include/linux/atm*
F:	include/uapi/linux/atm*

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

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

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

ATOMIC INFRASTRUCTURE
M:	Will Deacon <will@kernel.org>
M:	Peter Zijlstra <peterz@infradead.org>
R:	Boqun Feng <boqun.feng@gmail.com>
R:	Mark Rutland <mark.rutland@arm.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	arch/*/include/asm/atomic*.h
F:	include/*/atomic*.h
F:	include/linux/refcount.h
F:	Documentation/atomic_*.txt
F:	scripts/atomic/

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

ATUSB IEEE 802.15.4 RADIO DRIVER
M:	Stefan Schmidt <stefan@datenfreihafen.org>
L:	linux-wpan@vger.kernel.org
S:	Maintained
F:	drivers/net/ieee802154/at86rf230.h
F:	drivers/net/ieee802154/atusb.c
F:	drivers/net/ieee802154/atusb.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)
S:	Supported
W:	https://github.com/linux-audit
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pcmoore/audit.git
F:	include/asm-generic/audit_*.h
F:	include/linux/audit.h
F:	include/linux/audit_arch.h
F:	include/uapi/linux/audit.h
F:	kernel/audit*
F:	lib/*audit.c

AUXILIARY DISPLAY DRIVERS
M:	Miguel Ojeda <ojeda@kernel.org>
S:	Maintained
F:	Documentation/devicetree/bindings/auxdisplay/
F:	drivers/auxdisplay/
F:	include/linux/cfag12864b.h

AVIA HX711 ANALOG DIGITAL CONVERTER IIO DRIVER
M:	Andreas Klinger <ak@it-klinger.de>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/adc/avia-hx711.yaml
F:	drivers/iio/adc/hx711.c

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

AXI-FAN-CONTROL HARDWARE MONITOR DRIVER
M:	Nuno Sá <nuno.sa@analog.com>
L:	linux-hwmon@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/hwmon/adi,axi-fan-control.yaml
F:	drivers/hwmon/axi-fan-control.c

AXXIA I2C CONTROLLER
M:	Krzysztof Adamski <krzysztof.adamski@nokia.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-axxia.txt
F:	drivers/i2c/busses/i2c-axxia.c

AZ6007 DVB DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/radio/radio-aztech*

B43 WIRELESS DRIVER
L:	linux-wireless@vger.kernel.org
L:	b43-dev@lists.infradead.org
S:	Odd Fixes
W:	https://wireless.wiki.kernel.org/en/users/Drivers/b43
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
S:	Maintained
W:	https://wireless.wiki.kernel.org/en/users/Drivers/b43
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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lee/backlight.git
F:	Documentation/ABI/stable/sysfs-class-backlight
F:	Documentation/ABI/testing/sysfs-class-backlight
F:	Documentation/devicetree/bindings/leds/backlight
F:	drivers/video/backlight/
F:	include/linux/backlight.h
F:	include/linux/pwm_backlight.h

BARCO P50 GPIO DRIVER
M:	Santosh Kumar Yadav <santoshkumar.yadav@barco.com>
M:	Peter Korsgaard <peter.korsgaard@barco.com>
S:	Maintained
F:	drivers/platform/x86/barco-p50-gpio.c

BATMAN ADVANCED
M:	Marek Lindner <mareklindner@neomailbox.ch>
M:	Simon Wunderlich <sw@simonwunderlich.de>
M:	Antonio Quartulli <a@unstable.cc>
M:	Sven Eckelmann <sven@narfation.org>
L:	b.a.t.m.a.n@lists.open-mesh.org (moderated for non-subscribers)
S:	Maintained
W:	https://www.open-mesh.org/
Q:	https://patchwork.open-mesh.org/project/batman/list/
B:	https://www.open-mesh.org/projects/batman-adv/issues
C:	ircs://irc.hackint.org/batadv
T:	git https://git.open-mesh.org/linux-merge.git
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
S:	Maintained
W:	http://www.baycom.org/~tom/ham/ham.html
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
S:	Maintained
W:	http://bcache.evilpiepirate.org
C:	irc://irc.oftc.net/bcache
F:	drivers/md/bcache/

BDISP ST MEDIA DRIVER
M:	Fabien Dessenne <fabien.dessenne@foss.st.com>
L:	linux-media@vger.kernel.org
S:	Supported
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/platform/st/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.rst
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:	Documentation/block/bfq-iosched.rst
F:	block/bfq-*

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

BITMAP API
M:	Yury Norov <yury.norov@gmail.com>
R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
R:	Rasmus Villemoes <linux@rasmusvillemoes.dk>
S:	Maintained
F:	include/linux/bitmap.h
F:	include/linux/cpumask.h
F:	include/linux/find.h
F:	include/linux/nodemask.h
F:	lib/bitmap.c
F:	lib/cpumask.c
F:	lib/find_bit.c
F:	lib/find_bit_benchmark.c
F:	lib/nodemask.c
F:	lib/test_bitmap.c
F:	tools/include/linux/bitmap.h
F:	tools/include/linux/find.h
F:	tools/lib/bitmap.c
F:	tools/lib/find_bit.c

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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git
F:	Documentation/ABI/stable/sysfs-block
F:	Documentation/block/
F:	block/
F:	drivers/block/
F:	include/linux/bio.h
F:	include/linux/blk*
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>
M:	Luiz Augusto von Dentz <luiz.dentz@gmail.com>
L:	linux-bluetooth@vger.kernel.org
S:	Supported
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
F:	drivers/bluetooth/

BLUETOOTH SUBSYSTEM
M:	Marcel Holtmann <marcel@holtmann.org>
M:	Johan Hedberg <johan.hedberg@gmail.com>
M:	Luiz Augusto von Dentz <luiz.dentz@gmail.com>
L:	linux-bluetooth@vger.kernel.org
S:	Supported
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
F:	include/net/bluetooth/
F:	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
S:	Supported
W:	http://sourceforge.net/projects/bonding/
F:	Documentation/networking/bonding.rst
F:	drivers/net/bonding/
F:	include/net/bond*
F:	include/uapi/linux/if_bonding.h

BOSCH SENSORTEC BMA400 ACCELEROMETER IIO DRIVER
M:	Dan Robertson <dan@dlrobertson.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/accel/bosch,bma400.yaml
F:	drivers/iio/accel/bma400*

BPF [GENERAL] (Safe Dynamic Programs and Tools)
M:	Alexei Starovoitov <ast@kernel.org>
M:	Daniel Borkmann <daniel@iogearbox.net>
M:	Andrii Nakryiko <andrii@kernel.org>
R:	Martin KaFai Lau <martin.lau@linux.dev>
R:	Song Liu <song@kernel.org>
R:	Yonghong Song <yhs@fb.com>
R:	John Fastabend <john.fastabend@gmail.com>
R:	KP Singh <kpsingh@kernel.org>
R:	Stanislav Fomichev <sdf@google.com>
R:	Hao Luo <haoluo@google.com>
R:	Jiri Olsa <jolsa@kernel.org>
L:	bpf@vger.kernel.org
S:	Supported
W:	https://bpf.io/
Q:	https://patchwork.kernel.org/project/netdevbpf/list/?delegate=121173
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
F:	Documentation/bpf/
F:	Documentation/networking/filter.rst
F:	Documentation/userspace-api/ebpf/
F:	arch/*/net/*
F:	include/linux/bpf*
F:	include/linux/btf*
F:	include/linux/filter.h
F:	include/trace/events/xdp.h
F:	include/uapi/linux/bpf*
F:	include/uapi/linux/btf*
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:	scripts/bpf_doc.py
F:	scripts/pahole-flags.sh
F:	scripts/pahole-version.sh
F:	tools/bpf/
F:	tools/lib/bpf/
F:	tools/testing/selftests/bpf/

BPF JIT for ARM
M:	Shubham Bansal <illusionist.neo@gmail.com>
L:	bpf@vger.kernel.org
S:	Odd Fixes
F:	arch/arm/net/

BPF JIT for ARM64
M:	Daniel Borkmann <daniel@iogearbox.net>
M:	Alexei Starovoitov <ast@kernel.org>
M:	Zi Shen Lim <zlim.lnx@gmail.com>
L:	bpf@vger.kernel.org
S:	Supported
F:	arch/arm64/net/

BPF JIT for MIPS (32-BIT AND 64-BIT)
M:	Johan Almbladh <johan.almbladh@anyfinetworks.com>
M:	Paul Burton <paulburton@kernel.org>
L:	bpf@vger.kernel.org
S:	Maintained
F:	arch/mips/net/

BPF JIT for NFP NICs
M:	Jakub Kicinski <kuba@kernel.org>
L:	bpf@vger.kernel.org
S:	Odd Fixes
F:	drivers/net/ethernet/netronome/nfp/bpf/

BPF JIT for POWERPC (32-BIT AND 64-BIT)
M:	Naveen N. Rao <naveen.n.rao@linux.ibm.com>
M:	Michael Ellerman <mpe@ellerman.id.au>
L:	bpf@vger.kernel.org
S:	Supported
F:	arch/powerpc/net/

BPF JIT for RISC-V (32-bit)
M:	Luke Nelson <luke.r.nels@gmail.com>
M:	Xi Wang <xi.wang@gmail.com>
L:	bpf@vger.kernel.org
S:	Maintained
F:	arch/riscv/net/
X:	arch/riscv/net/bpf_jit_comp64.c

BPF JIT for RISC-V (64-bit)
M:	Björn Töpel <bjorn@kernel.org>
L:	bpf@vger.kernel.org
S:	Maintained
F:	arch/riscv/net/
X:	arch/riscv/net/bpf_jit_comp32.c

BPF JIT for S390
M:	Ilya Leoshkevich <iii@linux.ibm.com>
M:	Heiko Carstens <hca@linux.ibm.com>
M:	Vasily Gorbik <gor@linux.ibm.com>
L:	bpf@vger.kernel.org
S:	Supported
F:	arch/s390/net/
X:	arch/s390/net/pnet.c

BPF JIT for SPARC (32-BIT AND 64-BIT)
M:	David S. Miller <davem@davemloft.net>
L:	bpf@vger.kernel.org
S:	Odd Fixes
F:	arch/sparc/net/

BPF JIT for X86 32-BIT
M:	Wang YanQing <udknight@gmail.com>
L:	bpf@vger.kernel.org
S:	Odd Fixes
F:	arch/x86/net/bpf_jit_comp32.c

BPF JIT for X86 64-BIT
M:	Alexei Starovoitov <ast@kernel.org>
M:	Daniel Borkmann <daniel@iogearbox.net>
L:	bpf@vger.kernel.org
S:	Supported
F:	arch/x86/net/
X:	arch/x86/net/bpf_jit_comp32.c

BPF [CORE]
M:	Alexei Starovoitov <ast@kernel.org>
M:	Daniel Borkmann <daniel@iogearbox.net>
R:	John Fastabend <john.fastabend@gmail.com>
L:	bpf@vger.kernel.org
S:	Maintained
F:	kernel/bpf/verifier.c
F:	kernel/bpf/tnum.c
F:	kernel/bpf/core.c
F:	kernel/bpf/syscall.c
F:	kernel/bpf/dispatcher.c
F:	kernel/bpf/trampoline.c
F:	include/linux/bpf*
F:	include/linux/filter.h

BPF [BTF]
M:	Martin KaFai Lau <martin.lau@linux.dev>
L:	bpf@vger.kernel.org
S:	Maintained
F:	kernel/bpf/btf.c
F:	include/linux/btf*

BPF [TRACING]
M:	Song Liu <song@kernel.org>
R:	Jiri Olsa <jolsa@kernel.org>
L:	bpf@vger.kernel.org
S:	Maintained
F:	kernel/trace/bpf_trace.c
F:	kernel/bpf/stackmap.c

BPF [NETWORKING] (tc BPF, sock_addr)
M:	Martin KaFai Lau <martin.lau@linux.dev>
M:	Daniel Borkmann <daniel@iogearbox.net>
R:	John Fastabend <john.fastabend@gmail.com>
L:	bpf@vger.kernel.org
L:	netdev@vger.kernel.org
S:	Maintained
F:	net/core/filter.c
F:	net/sched/act_bpf.c
F:	net/sched/cls_bpf.c

BPF [NETWORKING] (struct_ops, reuseport)
M:	Martin KaFai Lau <martin.lau@linux.dev>
L:	bpf@vger.kernel.org
L:	netdev@vger.kernel.org
S:	Maintained
F:	kernel/bpf/bpf_struct*

BPF [SECURITY & LSM] (Security Audit and Enforcement using BPF)
M:	KP Singh <kpsingh@kernel.org>
R:	Florent Revest <revest@chromium.org>
R:	Brendan Jackman <jackmanb@chromium.org>
L:	bpf@vger.kernel.org
S:	Maintained
F:	Documentation/bpf/prog_lsm.rst
F:	include/linux/bpf_lsm.h
F:	kernel/bpf/bpf_lsm.c
F:	security/bpf/

BPF [STORAGE & CGROUPS]
M:	Martin KaFai Lau <martin.lau@linux.dev>
L:	bpf@vger.kernel.org
S:	Maintained
F:	kernel/bpf/cgroup.c
F:	kernel/bpf/*storage.c
F:	kernel/bpf/bpf_lru*

BPF [RINGBUF]
M:	Andrii Nakryiko <andrii@kernel.org>
L:	bpf@vger.kernel.org
S:	Maintained
F:	kernel/bpf/ringbuf.c

BPF [ITERATOR]
M:	Yonghong Song <yhs@fb.com>
L:	bpf@vger.kernel.org
S:	Maintained
F:	kernel/bpf/*iter.c

BPF [L7 FRAMEWORK] (sockmap)
M:	John Fastabend <john.fastabend@gmail.com>
M:	Jakub Sitnicki <jakub@cloudflare.com>
L:	netdev@vger.kernel.org
L:	bpf@vger.kernel.org
S:	Maintained
F:	include/linux/skmsg.h
F:	net/core/skmsg.c
F:	net/core/sock_map.c
F:	net/ipv4/tcp_bpf.c
F:	net/ipv4/udp_bpf.c
F:	net/unix/unix_bpf.c

BPF [LIBRARY] (libbpf)
M:	Andrii Nakryiko <andrii@kernel.org>
L:	bpf@vger.kernel.org
S:	Maintained
F:	tools/lib/bpf/

BPF [TOOLING] (bpftool)
M:	Quentin Monnet <quentin@isovalent.com>
L:	bpf@vger.kernel.org
S:	Maintained
F:	kernel/bpf/disasm.*
F:	tools/bpf/bpftool/

BPF [SELFTESTS] (Test Runners & Infrastructure)
M:	Andrii Nakryiko <andrii@kernel.org>
R:	Mykola Lysenko <mykolal@fb.com>
L:	bpf@vger.kernel.org
S:	Maintained
F:	tools/testing/selftests/bpf/

BPF [MISC]
L:	bpf@vger.kernel.org
S:	Odd Fixes
K:	(?:\b|_)bpf(?:\b|_)

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/SF2 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:	Documentation/devicetree/bindings/net/dsa/brcm,b53.yaml
F:	drivers/net/dsa/b53/*
F:	drivers/net/dsa/bcm_sf2*
F:	include/linux/dsa/brcm.h
F:	include/linux/platform_data/b53.h

BROADCOM BCMBCA ARM ARCHITECTURE
M:	William Zhang <william.zhang@broadcom.com>
M:	Anand Gore <anand.gore@broadcom.com>
M:	Kursad Oney <kursad.oney@broadcom.com>
M:	Florian Fainelli <f.fainelli@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://github.com/broadcom/stblinux.git
F:	Documentation/devicetree/bindings/arm/bcm/brcm,bcmbca.yaml
F:	arch/arm64/boot/dts/broadcom/bcmbca/*
N:	bcmbca
N:	bcm[9]?47622
N:	bcm[9]?4912
N:	bcm[9]?63138
N:	bcm[9]?63146
N:	bcm[9]?63148
N:	bcm[9]?63158
N:	bcm[9]?63178
N:	bcm[9]?6756
N:	bcm[9]?6813
N:	bcm[9]?6846
N:	bcm[9]?6855
N:	bcm[9]?6856
N:	bcm[9]?6858
N:	bcm[9]?6878

BROADCOM BCM2711/BCM2835 ARM ARCHITECTURE
M:	Florian Fainelli <f.fainelli@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-rpi-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://github.com/broadcom/stblinux.git
F:	Documentation/devicetree/bindings/pci/brcm,stb-pcie.yaml
F:	drivers/pci/controller/pcie-brcmstb.c
F:	drivers/staging/vc04_services
N:	bcm2711
N:	bcm283*
N:	raspberrypi

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>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
S:	Maintained
T:	git git://github.com/broadcom/mach-bcm
F:	arch/arm/mach-bcm/
N:	bcm281*
N:	bcm113*
N:	bcm216*
N:	kona

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

BROADCOM BCM4908 ETHERNET DRIVER
M:	Rafał Miłecki <rafal@milecki.pl>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/brcm,bcm4908-enet.yaml
F:	drivers/net/ethernet/broadcom/bcm4908_enet.*
F:	drivers/net/ethernet/broadcom/unimac.h

BROADCOM BCM4908 PINMUX DRIVER
M:	Rafał Miłecki <rafal@milecki.pl>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pinctrl/brcm,bcm4908-pinctrl.yaml
F:	drivers/pinctrl/bcm/pinctrl-bcm4908.c

BROADCOM BCM5301X ARM ARCHITECTURE
M:	Florian Fainelli <f.fainelli@gmail.com>
M:	Hauke Mehrtens <hauke@hauke-m.de>
M:	Rafał Miłecki <zajec5@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/boot/dts/bcm470*
F:	arch/arm/boot/dts/bcm5301*
F:	arch/arm/boot/dts/bcm953012*
F:	arch/arm/mach-bcm/bcm_5301x.c

BROADCOM BCM53573 ARM ARCHITECTURE
M:	Florian Fainelli <f.fainelli@gmail.com>
M:	Rafał Miłecki <rafal@milecki.pl>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/boot/dts/bcm47189*
F:	arch/arm/boot/dts/bcm53573*

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:	Florian Fainelli <f.fainelli@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://github.com/broadcom/stblinux.git
F:	Documentation/devicetree/bindings/pci/brcm,stb-pcie.yaml
F:	arch/arm/boot/dts/bcm7*.dts*
F:	arch/arm/include/asm/hardware/cache-b15-rac.h
F:	arch/arm/mach-bcm/*brcmstb*
F:	arch/arm/mm/cache-b15-rac.c
F:	drivers/bus/brcmstb_gisb.c
F:	drivers/pci/controller/pcie-brcmstb.c
N:	brcmstb
N:	bcm7038
N:	bcm7120

BROADCOM BDC DRIVER
M:	Al Cooper <alcooperx@gmail.com>
L:	linux-usb@vger.kernel.org
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
S:	Maintained
F:	Documentation/devicetree/bindings/usb/brcm,bdc.yaml
F:	drivers/usb/gadget/udc/bdc/

BROADCOM BMIPS CPUFREQ DRIVER
M:	Markus Mayer <mmayer@broadcom.com>
R:	Broadcom internal kernel review list <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:	Florian Fainelli <f.fainelli@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-mips@vger.kernel.org
S:	Maintained
T:	git git://github.com/broadcom/stblinux.git
F:	arch/mips/bmips/*
F:	arch/mips/boot/dts/brcm/bcm*.dts*
F:	arch/mips/include/asm/mach-bmips/*
F:	arch/mips/kernel/*bmips*
F:	drivers/soc/bcm/bcm63xx
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 <rmody@marvell.com>
M:	GR-Linux-NIC-Dev@marvell.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:	Saurav Kashyap <skashyap@marvell.com>
M:	Javed Hasan <jhasan@marvell.com>
M:	GR-QLogic-Storage-Upstream@marvell.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/bnx2fc/

BROADCOM BNX2I 1/10 GIGABIT iSCSI DRIVER
M:	Nilesh Javali <njavali@marvell.com>
M:	Manish Rangankar <mrangankar@marvell.com>
M:	GR-QLogic-Storage-Upstream@marvell.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/bnx2i/

BROADCOM BNX2X 10 GIGABIT ETHERNET DRIVER
M:	Ariel Elior <aelior@marvell.com>
M:	Sudarsana Kalluru <skalluru@marvell.com>
M:	Manish Chopra <manishc@marvell.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/firmware/broadcom/tee_bnxt_fw.c
F:	drivers/net/ethernet/broadcom/bnxt/
F:	include/linux/firmware/broadcom/tee_bnxt_fw.h

BROADCOM BRCM80211 IEEE802.11n WIRELESS DRIVER
M:	Arend van Spriel <aspriel@gmail.com>
M:	Franky Lin <franky.lin@broadcom.com>
M:	Hante Meuleman <hante.meuleman@broadcom.com>
L:	linux-wireless@vger.kernel.org
L:	brcm80211-dev-list.pdl@broadcom.com
L:	SHA-cyfmac-dev-list@infineon.com
S:	Supported
F:	drivers/net/wireless/broadcom/brcm80211/

BROADCOM BRCMSTB GPIO DRIVER
M:	Doug Berger <opendmb@gmail.com>
M:	Florian Fainelli <f.fainelli@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
S:	Supported
F:	Documentation/devicetree/bindings/gpio/brcm,brcmstb-gpio.yaml
F:	drivers/gpio/gpio-brcmstb.c

BROADCOM BRCMSTB I2C DRIVER
M:	Kamal Dasu <kdasu.kdev@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-i2c@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/i2c/brcm,brcmstb-i2c.yaml
F:	drivers/i2c/busses/i2c-brcmstb.c

BROADCOM BRCMSTB UART DRIVER
M:	Al Cooper <alcooperx@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-serial@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/serial/brcm,bcm7271-uart.yaml
F:	drivers/tty/serial/8250/8250_bcm7271.c

BROADCOM BRCMSTB USB EHCI DRIVER
M:	Al Cooper <alcooperx@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/usb/brcm,bcm7445-ehci.yaml
F:	drivers/usb/host/ehci-brcm.*

BROADCOM BRCMSTB USB PIN MAP DRIVER
M:	Al Cooper <alcooperx@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/usb/brcm,usb-pinmap.yaml
F:	drivers/usb/misc/brcmstb-usb-pinmap.c

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

BROADCOM ETHERNET PHY DRIVERS
M:	Florian Fainelli <f.fainelli@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/net/broadcom-bcm87xx.txt
F:	drivers/net/phy/bcm*.[ch]
F:	drivers/net/phy/broadcom.c
F:	include/linux/brcmphy.h

BROADCOM GENET ETHERNET DRIVER
M:	Doug Berger <opendmb@gmail.com>
M:	Florian Fainelli <f.fainelli@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/net/brcm,bcmgenet.yaml
F:	Documentation/devicetree/bindings/net/brcm,unimac-mdio.yaml
F:	drivers/net/ethernet/broadcom/genet/
F:	drivers/net/ethernet/broadcom/unimac.h
F:	drivers/net/mdio/mdio-bcm-unimac.c
F:	include/linux/platform_data/bcmgenet.h
F:	include/linux/platform_data/mdio-bcm-unimac.h

BROADCOM IPROC ARM ARCHITECTURE
M:	Ray Jui <rjui@broadcom.com>
M:	Scott Branden <sbranden@broadcom.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://github.com/broadcom/stblinux.git
F:	arch/arm64/boot/dts/broadcom/northstar2/*
F:	arch/arm64/boot/dts/broadcom/stingray/*
F:	drivers/clk/bcm/clk-ns*
F:	drivers/clk/bcm/clk-sr*
F:	drivers/pinctrl/bcm/pinctrl-ns*
F:	include/dt-bindings/clock/bcm-sr*
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
N:	stingray

BROADCOM IPROC GBIT ETHERNET DRIVER
M:	Rafał Miłecki <rafal@milecki.pl>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/brcm,amac.yaml
F:	drivers/net/ethernet/broadcom/bgmac*
F:	drivers/net/ethernet/broadcom/unimac.h

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

BROADCOM MPI3 STORAGE CONTROLLER DRIVER
M:	Sathya Prakash Veerichetty <sathya.prakash@broadcom.com>
M:	Kashyap Desai <kashyap.desai@broadcom.com>
M:	Sumit Saxena <sumit.saxena@broadcom.com>
M:	Sreekanth Reddy <sreekanth.reddy@broadcom.com>
L:	mpi3mr-linuxdrv.pdl@broadcom.com
L:	linux-scsi@vger.kernel.org
S:	Supported
W:	https://www.broadcom.com/support/storage
F:	drivers/scsi/mpi3mr/

BROADCOM NETXTREME-E ROCE DRIVER
M:	Selvin Xavier <selvin.xavier@broadcom.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
W:	http://www.broadcom.com
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@vger.kernel.org
S:	Maintained
F:	drivers/firmware/broadcom/*

BROADCOM PMB (POWER MANAGEMENT BUS) DRIVER
M:	Rafał Miłecki <rafal@milecki.pl>
M:	Florian Fainelli <f.fainelli@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-pm@vger.kernel.org
S:	Maintained
T:	git git://github.com/broadcom/stblinux.git
F:	drivers/soc/bcm/bcm63xx/bcm-pmb.c
F:	include/dt-bindings/soc/bcm-pmb.h

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 SPI DRIVER
M:	Kamal Dasu <kdasu.kdev@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
S:	Maintained
F:	Documentation/devicetree/bindings/spi/brcm,spi-bcm-qspi.yaml
F:	drivers/spi/spi-bcm-qspi.*
F:	drivers/spi/spi-brcmstb-qspi.c
F:	drivers/spi/spi-iproc-qspi.c

BROADCOM STB AVS CPUFREQ DRIVER
M:	Markus Mayer <mmayer@broadcom.com>
R:	Broadcom internal kernel review list <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>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/thermal/brcm,avs-tmon.yaml
F:	drivers/thermal/broadcom/brcmstb*

BROADCOM STB DPFE DRIVER
M:	Markus Mayer <mmayer@broadcom.com>
R:	Broadcom internal kernel review list <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.yaml
F:	drivers/memory/brcmstb_dpfe.c

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

BROADCOM STB PCIE DRIVER
M:	Jim Quinlan <jim2101024@gmail.com>
M:	Nicolas Saenz Julienne <nsaenz@kernel.org>
M:	Florian Fainelli <f.fainelli@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/brcm,stb-pcie.yaml
F:	drivers/pci/controller/pcie-brcmstb.c

BROADCOM SYSTEMPORT ETHERNET DRIVER
M:	Florian Fainelli <f.fainelli@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/broadcom/bcmsysport.*
F:	drivers/net/ethernet/broadcom/unimac.h
F:	Documentation/devicetree/bindings/net/brcm,systemport.yaml

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.*

BROADCOM VK DRIVER
M:	Scott Branden <scott.branden@broadcom.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
S:	Supported
F:	drivers/misc/bcm-vk/
F:	include/uapi/linux/misc/bcm_vk.h

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 <rmody@marvell.com>
M:	Sudarsana Kalluru <skalluru@marvell.com>
M:	GR-Linux-NIC-Dev@marvell.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)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
F:	Documentation/sound/cards/bt87x.rst
F:	sound/pci/bt87x.c

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

BTRFS FILE SYSTEM
M:	Chris Mason <clm@fb.com>
M:	Josef Bacik <josef@toxicpanda.com>
M:	David Sterba <dsterba@suse.com>
L:	linux-btrfs@vger.kernel.org
S:	Maintained
W:	http://btrfs.wiki.kernel.org/
Q:	http://patchwork.kernel.org/project/linux-btrfs/list/
C:	irc://irc.libera.chat/btrfs
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kdave/linux.git
F:	Documentation/filesystems/btrfs.rst
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
S:	Odd fixes
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/driver-api/media/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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/linux.git
F:	Documentation/devicetree/bindings/interconnect/samsung,exynos-bus.yaml
F:	drivers/devfreq/exynos-bus.c

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)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
F:	sound/pci/oxygen/

C-SKY ARCHITECTURE
M:	Guo Ren <guoren@kernel.org>
L:	linux-csky@vger.kernel.org
S:	Supported
T:	git https://github.com/c-sky/csky-linux.git
F:	Documentation/devicetree/bindings/csky/
F:	Documentation/devicetree/bindings/interrupt-controller/csky,*
F:	Documentation/devicetree/bindings/timer/csky,*
F:	arch/csky/
F:	drivers/clocksource/timer-gx6605s.c
F:	drivers/clocksource/timer-mp-csky.c
F:	drivers/irqchip/irq-csky-*
N:	csky
K:	csky

CA8210 IEEE-802.15.4 RADIO DRIVER
L:	linux-wpan@vger.kernel.org
S:	Orphan
W:	https://github.com/Cascoda/ca8210-linux.git
F:	Documentation/devicetree/bindings/net/ieee802154/ca8210.txt
F:	drivers/net/ieee802154/ca8210.c

CANAAN/KENDRYTE K210 SOC FPIOA DRIVER
M:	Damien Le Moal <damien.lemoal@wdc.com>
L:	linux-riscv@lists.infradead.org
L:	linux-gpio@vger.kernel.org (pinctrl driver)
F:	Documentation/devicetree/bindings/pinctrl/canaan,k210-fpioa.yaml
F:	drivers/pinctrl/pinctrl-k210.c

CANAAN/KENDRYTE K210 SOC RESET CONTROLLER DRIVER
M:	Damien Le Moal <damien.lemoal@wdc.com>
L:	linux-kernel@vger.kernel.org
L:	linux-riscv@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/reset/canaan,k210-rst.yaml
F:	drivers/reset/reset-k210.c

CANAAN/KENDRYTE K210 SOC SYSTEM CONTROLLER DRIVER
M:	Damien Le Moal <damien.lemoal@wdc.com>
L:	linux-riscv@lists.infradead.org
S:	Maintained
F:      Documentation/devicetree/bindings/mfd/canaan,k210-sysctl.yaml
F:	drivers/soc/canaan/
F:	include/soc/canaan/

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.rst
F:	fs/cachefiles/

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

CADENCE NAND DRIVER
L:	linux-mtd@lists.infradead.org
S:	Orphan
F:	Documentation/devicetree/bindings/mtd/cadence-nand-controller.txt
F:	drivers/mtd/nand/raw/cadence-nand-controller.c

CADENCE USB3 DRD IP DRIVER
M:	Peter Chen <peter.chen@kernel.org>
M:	Pawel Laszczak <pawell@cadence.com>
R:	Roger Quadros <rogerq@kernel.org>
R:	Aswath Govindraju <a-govindraju@ti.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/peter.chen/usb.git
F:	Documentation/devicetree/bindings/usb/cdns,usb3.yaml
F:	drivers/usb/cdns3/
X:	drivers/usb/cdns3/cdnsp*

CADENCE USBSSP DRD IP DRIVER
M:	Pawel Laszczak <pawell@cadence.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/peter.chen/usb.git
F:	drivers/usb/cdns3/
X:	drivers/usb/cdns3/cdns3*

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

CAFE CMOS INTEGRATED CAMERA CONTROLLER DRIVER
L:	linux-media@vger.kernel.org
S:	Orphan
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/admin-guide/media/cafe_ccic*
F:	drivers/media/platform/marvell/

CAIF NETWORK LAYER
L:	netdev@vger.kernel.org
S:	Orphan
F:	Documentation/networking/caif/
F:	drivers/net/caif/
F:	include/net/caif/
F:	include/uapi/linux/caif/
F:	net/caif/

CAKE QDISC
M:	Toke Høiland-Jørgensen <toke@toke.dk>
L:	cake@lists.bufferbloat.net (moderated for non-subscribers)
S:	Maintained
F:	net/sched/sch_cake.c

CAN NETWORK DRIVERS
M:	Wolfgang Grandegger <wg@grandegger.com>
M:	Marc Kleine-Budde <mkl@pengutronix.de>
L:	linux-can@vger.kernel.org
S:	Maintained
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
F:	Documentation/devicetree/bindings/net/can/
F:	Documentation/devicetree/bindings/phy/ti,tcan104x-can.yaml
F:	drivers/net/can/
F:	drivers/phy/phy-can-transceiver.c
F:	include/linux/can/bittiming.h
F:	include/linux/can/dev.h
F:	include/linux/can/length.h
F:	include/linux/can/platform/
F:	include/linux/can/rx-offload.h
F:	include/uapi/linux/can/error.h
F:	include/uapi/linux/can/netlink.h
F:	include/uapi/linux/can/vxcan.h

CAN NETWORK LAYER
M:	Oliver Hartkopp <socketcan@hartkopp.net>
M:	Marc Kleine-Budde <mkl@pengutronix.de>
L:	linux-can@vger.kernel.org
S:	Maintained
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
F:	Documentation/networking/can.rst
F:	include/linux/can/can-ml.h
F:	include/linux/can/core.h
F:	include/linux/can/skb.h
F:	include/net/netns/can.h
F:	include/uapi/linux/can.h
F:	include/uapi/linux/can/bcm.h
F:	include/uapi/linux/can/gw.h
F:	include/uapi/linux/can/isotp.h
F:	include/uapi/linux/can/raw.h
F:	net/can/

CAN-J1939 NETWORK LAYER
M:	Robin van der Gracht <robin@protonic.nl>
M:	Oleksij Rempel <o.rempel@pengutronix.de>
R:	kernel@pengutronix.de
L:	linux-can@vger.kernel.org
S:	Maintained
F:	Documentation/networking/j1939.rst
F:	include/uapi/linux/can/j1939.h
F:	net/can/j1939/

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:	kernel/capability.c
F:	security/commoncap.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
S:	Maintained
W:	https://wireless.wiki.kernel.org/en/users/Drivers/carl9170
F:	drivers/net/wireless/ath/carl9170/

CAVIUM I2C DRIVER
M:	Robert Richter <rric@kernel.org>
S:	Odd Fixes
W:	http://www.marvell.com
F:	drivers/i2c/busses/i2c-octeon*
F:	drivers/i2c/busses/i2c-thunderx*

CAVIUM LIQUIDIO NETWORK DRIVER
M:	Derek Chickles <dchickles@marvell.com>
M:	Satanand Burla <sburla@marvell.com>
M:	Felix Manlunas <fmanlunas@marvell.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.marvell.com
F:	drivers/net/ethernet/cavium/liquidio/

CAVIUM MMC DRIVER
M:	Robert Richter <rric@kernel.org>
S:	Odd Fixes
W:	http://www.marvell.com
F:	drivers/mmc/host/cavium*

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

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

CBS/ETF/TAPRIO QDISCS
M:	Vinicius Costa Gomes <vinicius.gomes@intel.com>
S:	Maintained
L:	netdev@vger.kernel.org
F:	net/sched/sch_cbs.c
F:	net/sched/sch_etf.c
F:	net/sched/sch_taprio.c

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

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

CCTRNG ARM TRUSTZONE CRYPTOCELL TRUE RANDOM NUMBER GENERATOR (TRNG) DRIVER
M:	Hadar Gat <hadar.gat@arm.com>
L:	linux-crypto@vger.kernel.org
S:	Supported
F:	drivers/char/hw_random/cctrng.c
F:	drivers/char/hw_random/cctrng.h
F:	Documentation/devicetree/bindings/rng/arm-cctrng.yaml
W:	https://developer.arm.com/products/system-ip/trustzone-cryptocell/cryptocell-700-family

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

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

CELL BROADBAND ENGINE ARCHITECTURE
M:	Arnd Bergmann <arnd@arndb.de>
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
W:	http://www.ibm.com/developerworks/power/cell/
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/platforms/cell/

CELLWISE CW2015 BATTERY DRIVER
M:	Tobias Schrammm <t.schramm@manjaro.org>
S:	Maintained
F:	Documentation/devicetree/bindings/power/supply/cw2015_battery.yaml
F:	drivers/power/supply/cw2015_battery.c

CEPH COMMON CODE (LIBCEPH)
M:	Ilya Dryomov <idryomov@gmail.com>
M:	Xiubo Li <xiubli@redhat.com>
R:	Jeff Layton <jlayton@kernel.org>
L:	ceph-devel@vger.kernel.org
S:	Supported
W:	http://ceph.com/
T:	git git://github.com/ceph/ceph-client.git
F:	include/linux/ceph/
F:	include/linux/crush/
F:	net/ceph/

CEPH DISTRIBUTED FILE SYSTEM CLIENT (CEPH)
M:	Xiubo Li <xiubli@redhat.com>
M:	Ilya Dryomov <idryomov@gmail.com>
R:	Jeff Layton <jlayton@kernel.org>
L:	ceph-devel@vger.kernel.org
S:	Supported
W:	http://ceph.com/
T:	git git://github.com/ceph/ceph-client.git
F:	Documentation/filesystems/ceph.rst
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/admin-guide/module-signing.rst
F:	certs/
F:	scripts/check-blacklist-hashes.awk
F:	scripts/sign-file.c
F:	tools/certs/

CFAG12864B LCD DRIVER
M:	Miguel Ojeda <ojeda@kernel.org>
S:	Maintained
F:	drivers/auxdisplay/cfag12864b.c
F:	include/linux/cfag12864b.h

CFAG12864BFB LCD FRAMEBUFFER DRIVER
M:	Miguel Ojeda <ojeda@kernel.org>
S:	Maintained
F:	drivers/auxdisplay/cfag12864bfb.c
F:	include/linux/cfag12864b.h

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

CHECKPATCH
M:	Andy Whitcroft <apw@canonical.com>
M:	Joe Perches <joe@perches.com>
R:	Dwaipayan Ray <dwaipayanray1@gmail.com>
R:	Lukas Bulwahn <lukas.bulwahn@gmail.com>
S:	Maintained
F:	scripts/checkpatch.pl

CHECKPATCH DOCUMENTATION
M:	Dwaipayan Ray <dwaipayanray1@gmail.com>
M:	Lukas Bulwahn <lukas.bulwahn@gmail.com>
R:	Joe Perches <joe@perches.com>
S:	Maintained
F:	Documentation/dev-tools/checkpatch.rst

CHINESE DOCUMENTATION
M:	Alex Shi <alexs@kernel.org>
M:	Yanteng Si <siyanteng@loongson.cn>
S:	Maintained
F:	Documentation/translations/zh_CN/

CHIPIDEA USB HIGH SPEED DUAL ROLE CONTROLLER
M:	Peter Chen <peter.chen@kernel.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/peter.chen/usb.git
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.yaml
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>
L:	chrome-platform@lists.linux.dev
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/chrome-platform/linux.git
F:	drivers/platform/chrome/

CHROMEOS EC CODEC DRIVER
M:	Cheng-Yi Chiang <cychiang@chromium.org>
M:	Tzung-Bi Shih <tzungbi@google.com>
R:	Guenter Roeck <groeck@chromium.org>
L:	chrome-platform@lists.linux.dev
S:	Maintained
F:	Documentation/devicetree/bindings/sound/google,cros-ec-codec.yaml
F:	sound/soc/codecs/cros_ec_codec.*

CHROMEOS EC SUBDRIVERS
M:	Benson Leung <bleung@chromium.org>
R:	Guenter Roeck <groeck@chromium.org>
L:	chrome-platform@lists.linux.dev
S:	Maintained
F:	drivers/power/supply/cros_usbpd-charger.c
N:	cros_ec
N:	cros-ec

CHROMEOS EC USB TYPE-C DRIVER
M:	Prashant Malani <pmalani@chromium.org>
L:	chrome-platform@lists.linux.dev
S:	Maintained
F:	drivers/platform/chrome/cros_ec_typec.c

CHROMEOS EC USB PD NOTIFY DRIVER
M:	Prashant Malani <pmalani@chromium.org>
L:	chrome-platform@lists.linux.dev
S:	Maintained
F:	drivers/platform/chrome/cros_usbpd_notify.c
F:	include/linux/platform_data/cros_usbpd_notify.h

CHRONTEL CH7322 CEC DRIVER
M:	Joe Tessler <jrt@google.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/chrontel,ch7322.yaml
F:	drivers/media/cec/i2c/ch7322.c

CIRRUS LOGIC AUDIO CODEC DRIVERS
M:	James Schulman <james.schulman@cirrus.com>
M:	David Rhodes <david.rhodes@cirrus.com>
M:	Lucas Tanure <tanureal@opensource.cirrus.com>
M:	Richard Fitzgerald <rf@opensource.cirrus.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
L:	patches@opensource.cirrus.com
S:	Maintained
F:	Documentation/devicetree/bindings/sound/cirrus,cs*
F:	include/dt-bindings/sound/cs*
F:	sound/pci/hda/cs*
F:	sound/soc/codecs/cs*

CIRRUS LOGIC DSP FIRMWARE DRIVER
M:	Simon Trimmer <simont@opensource.cirrus.com>
M:	Charles Keepax <ckeepax@opensource.cirrus.com>
M:	Richard Fitzgerald <rf@opensource.cirrus.com>
L:	patches@opensource.cirrus.com
S:	Supported
W:	https://github.com/CirrusLogic/linux-drivers/wiki
T:	git https://github.com/CirrusLogic/linux-drivers.git
F:	drivers/firmware/cirrus/*
F:	include/linux/firmware/cirrus/*

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

CIRRUS LOGIC LOCHNAGAR DRIVER
M:	Charles Keepax <ckeepax@opensource.cirrus.com>
M:	Richard Fitzgerald <rf@opensource.cirrus.com>
L:	patches@opensource.cirrus.com
S:	Supported
F:	Documentation/devicetree/bindings/clock/cirrus,lochnagar.yaml
F:	Documentation/devicetree/bindings/hwmon/cirrus,lochnagar.yaml
F:	Documentation/devicetree/bindings/mfd/cirrus,lochnagar.yaml
F:	Documentation/devicetree/bindings/pinctrl/cirrus,lochnagar.yaml
F:	Documentation/devicetree/bindings/sound/cirrus,lochnagar.yaml
F:	Documentation/hwmon/lochnagar.rst
F:	drivers/clk/clk-lochnagar.c
F:	drivers/hwmon/lochnagar-hwmon.c
F:	drivers/mfd/lochnagar-i2c.c
F:	drivers/pinctrl/cirrus/pinctrl-lochnagar.c
F:	drivers/regulator/lochnagar-regulator.c
F:	include/dt-bindings/clk/lochnagar.h
F:	include/dt-bindings/pinctrl/lochnagar.h
F:	include/linux/mfd/lochnagar*
F:	sound/soc/codecs/lochnagar-sc.c

CIRRUS LOGIC MADERA CODEC DRIVERS
M:	Charles Keepax <ckeepax@opensource.cirrus.com>
M:	Richard Fitzgerald <rf@opensource.cirrus.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
L:	patches@opensource.cirrus.com
S:	Supported
W:	https://github.com/CirrusLogic/linux-drivers/wiki
T:	git https://github.com/CirrusLogic/linux-drivers.git
F:	Documentation/devicetree/bindings/mfd/cirrus,madera.yaml
F:	Documentation/devicetree/bindings/pinctrl/cirrus,madera.yaml
F:	Documentation/devicetree/bindings/sound/cirrus,madera.yaml
F:	drivers/gpio/gpio-madera*
F:	drivers/irqchip/irq-madera*
F:	drivers/mfd/cs47l*
F:	drivers/mfd/madera*
F:	drivers/pinctrl/cirrus/*
F:	include/dt-bindings/sound/madera*
F:	include/linux/irqchip/irq-madera*
F:	include/linux/mfd/madera/*
F:	include/sound/madera*
F:	sound/soc/codecs/cs47l*
F:	sound/soc/codecs/madera*

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>
S:	Supported
F:	drivers/net/ethernet/cisco/enic/

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

CLANG-FORMAT FILE
M:	Miguel Ojeda <ojeda@kernel.org>
S:	Maintained
F:	.clang-format

CLANG/LLVM BUILD SUPPORT
M:	Nathan Chancellor <nathan@kernel.org>
M:	Nick Desaulniers <ndesaulniers@google.com>
R:	Tom Rix <trix@redhat.com>
L:	llvm@lists.linux.dev
S:	Supported
W:	https://clangbuiltlinux.github.io/
B:	https://github.com/ClangBuiltLinux/linux/issues
C:	irc://irc.libera.chat/clangbuiltlinux
F:	Documentation/kbuild/llvm.rst
F:	include/linux/compiler-clang.h
F:	scripts/Makefile.clang
F:	scripts/clang-tools/
K:	\b(?i:clang|llvm)\b

CLANG CONTROL FLOW INTEGRITY SUPPORT
M:	Sami Tolvanen <samitolvanen@google.com>
M:	Kees Cook <keescook@chromium.org>
R:	Nathan Chancellor <nathan@kernel.org>
R:	Nick Desaulniers <ndesaulniers@google.com>
L:	llvm@lists.linux.dev
S:	Supported
B:	https://github.com/ClangBuiltLinux/linux/issues
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
F:	include/linux/cfi.h
F:	kernel/cfi.c

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
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core
F:	Documentation/devicetree/bindings/timer/
F:	drivers/clocksource/

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 <hverkuil-cisco@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Supported
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/pci/cobalt/

COCCINELLE/Semantic Patches (SmPL)
M:	Julia Lawall <Julia.Lawall@inria.fr>
M:	Nicolas Palix <nicolas.palix@imag.fr>
L:	cocci@inria.fr (moderated for non-subscribers)
S:	Supported
W:	https://coccinelle.gitlabpages.inria.fr/website/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jlawall/linux.git
F:	Documentation/dev-tools/coccinelle.rst
F:	scripts/coccicheck
F:	scripts/coccinelle/

CODA FILE SYSTEM
M:	Jan Harkes <jaharkes@cs.cmu.edu>
M:	coda@cs.cmu.edu
L:	codalist@coda.cs.cmu.edu
S:	Maintained
W:	http://www.coda.cs.cmu.edu/
F:	Documentation/filesystems/coda.rst
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.yaml
F:	drivers/media/platform/chips-media/

CODE OF CONDUCT
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
S:	Supported
F:	Documentation/process/code-of-conduct-interpretation.rst
F:	Documentation/process/code-of-conduct.rst

COMEDI DRIVERS
M:	Ian Abbott <abbotti@mev.co.uk>
M:	H Hartley Sweeten <hsweeten@visionengravers.com>
S:	Odd Fixes
F:	drivers/comedi/
F:	include/linux/comedi/
F:	include/uapi/linux/comedi.h

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

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

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

COMPILER ATTRIBUTES
M:	Miguel Ojeda <ojeda@kernel.org>
R:	Nick Desaulniers <ndesaulniers@google.com>
S:	Maintained
F:	include/linux/compiler_attributes.h

COMPUTE EXPRESS LINK (CXL)
M:	Alison Schofield <alison.schofield@intel.com>
M:	Vishal Verma <vishal.l.verma@intel.com>
M:	Ira Weiny <ira.weiny@intel.com>
M:	Ben Widawsky <bwidawsk@kernel.org>
M:	Dan Williams <dan.j.williams@intel.com>
L:	linux-cxl@vger.kernel.org
S:	Maintained
F:	drivers/cxl/
F:	include/uapi/linux/cxl_mem.h

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

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

CONSOLE SUBSYSTEM
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
S:	Supported
F:	drivers/video/console/
F:	include/linux/console*

CONTEXT TRACKING
M:	Frederic Weisbecker <frederic@kernel.org>
M:	"Paul E. McKenney" <paulmck@kernel.org>
S:	Maintained
F:	kernel/context_tracking.c
F:	include/linux/context_tracking*

CONTROL GROUP (CGROUP)
M:	Tejun Heo <tj@kernel.org>
M:	Zefan Li <lizefan.x@bytedance.com>
M:	Johannes Weiner <hannes@cmpxchg.org>
L:	cgroups@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup.git
F:	Documentation/admin-guide/cgroup-v1/
F:	Documentation/admin-guide/cgroup-v2.rst
F:	include/linux/cgroup*
F:	kernel/cgroup/
F:	tools/testing/selftests/cgroup/

CONTROL GROUP - BLOCK IO CONTROLLER (BLKIO)
M:	Tejun Heo <tj@kernel.org>
M:	Jens Axboe <axboe@kernel.dk>
L:	cgroups@vger.kernel.org
L:	linux-block@vger.kernel.org
T:	git git://git.kernel.dk/linux-block
F:	Documentation/admin-guide/cgroup-v1/blkio-controller.rst
F:	block/bfq-cgroup.c
F:	block/blk-cgroup.c
F:	block/blk-iolatency.c
F:	block/blk-throttle.c
F:	include/linux/blk-cgroup.h

CONTROL GROUP - CPUSET
M:	Zefan Li <lizefan.x@bytedance.com>
L:	cgroups@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup.git
F:	Documentation/admin-guide/cgroup-v1/cpusets.rst
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:	Roman Gushchin <roman.gushchin@linux.dev>
M:	Shakeel Butt <shakeelb@google.com>
R:	Muchun Song <songmuchun@bytedance.com>
L:	cgroups@vger.kernel.org
L:	linux-mm@kvack.org
S:	Maintained
F:	mm/memcontrol.c
F:	mm/swap_cgroup.c
F:	tools/testing/selftests/cgroup/memcg_protection.m
F:	tools/testing/selftests/cgroup/test_kmem.c
F:	tools/testing/selftests/cgroup/test_memcontrol.c

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

CORSAIR-CPRO HARDWARE MONITOR DRIVER
M:	Marius Zachmann <mail@mariuszachmann.de>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/corsair-cpro.c

CORSAIR-PSU HARDWARE MONITOR DRIVER
M:	Wilken Gottwalt <wilken.gottwalt@posteo.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/corsair-psu.rst
F:	drivers/hwmon/corsair-psu.c

COUNTER SUBSYSTEM
M:	William Breathitt Gray <william.gray@linaro.org>
L:	linux-iio@vger.kernel.org
S:	Maintained
T:	git https://git.linaro.org/people/william.gray/counter.git
F:	Documentation/ABI/testing/sysfs-bus-counter
F:	Documentation/driver-api/generic-counter.rst
F:	drivers/counter/
F:	include/linux/counter.h
F:	include/uapi/linux/counter.h
F:	tools/counter/

CP2615 I2C DRIVER
M:	Bence Csókás <bence98@sch.bme.hu>
S:	Maintained
F:	drivers/i2c/busses/i2c-cp2615.c

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 - VEXPRESS SPC ARM BIG LITTLE
M:	Viresh Kumar <viresh.kumar@linaro.org>
M:	Sudeep Holla <sudeep.holla@arm.com>
L:	linux-pm@vger.kernel.org
S:	Maintained
W:	http://www.arm.com/products/processors/technologies/biglittleprocessing.php
F:	drivers/cpufreq/vexpress-spc-cpufreq.c

CPU FREQUENCY SCALING FRAMEWORK
M:	"Rafael J. Wysocki" <rafael@kernel.org>
M:	Viresh Kumar <viresh.kumar@linaro.org>
L:	linux-pm@vger.kernel.org
S:	Maintained
B:	https://bugzilla.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/vireshk/pm.git (For ARM Updates)
F:	Documentation/admin-guide/pm/cpufreq.rst
F:	Documentation/admin-guide/pm/intel_pstate.rst
F:	Documentation/cpu-freq/
F:	Documentation/devicetree/bindings/cpufreq/
F:	drivers/cpufreq/
F:	include/linux/cpufreq.h
F:	include/linux/sched/cpufreq.h
F:	kernel/sched/cpufreq*.c
F:	tools/testing/selftests/cpufreq/

CPU IDLE TIME MANAGEMENT FRAMEWORK
M:	"Rafael J. Wysocki" <rafael@kernel.org>
M:	Daniel Lezcano <daniel.lezcano@linaro.org>
L:	linux-pm@vger.kernel.org
S:	Maintained
B:	https://bugzilla.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm.git
F:	Documentation/admin-guide/pm/cpuidle.rst
F:	Documentation/driver-api/pm/cpuidle.rst
F:	drivers/cpuidle/
F:	include/linux/cpuidle.h

CPU POWER MONITORING SUBSYSTEM
M:	Thomas Renninger <trenn@suse.com>
M:	Shuah Khan <shuah@kernel.org>
M:	Shuah Khan <skhan@linuxfoundation.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 <lpieralisi@kernel.org>
M:	Daniel Lezcano <daniel.lezcano@linaro.org>
L:	linux-pm@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm.git
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:	arch/arm/mach-exynos/pm.c
F:	drivers/cpuidle/cpuidle-exynos.c
F:	include/linux/platform_data/cpuidle-exynos.h

CPUIDLE DRIVER - ARM PSCI
M:	Lorenzo Pieralisi <lpieralisi@kernel.org>
M:	Sudeep Holla <sudeep.holla@arm.com>
L:	linux-pm@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	drivers/cpuidle/cpuidle-psci.c

CPUIDLE DRIVER - ARM PSCI PM DOMAIN
M:	Ulf Hansson <ulf.hansson@linaro.org>
L:	linux-pm@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	drivers/cpuidle/cpuidle-psci.h
F:	drivers/cpuidle/cpuidle-psci-domain.c

CPUIDLE DRIVER - DT IDLE PM DOMAIN
M:	Ulf Hansson <ulf.hansson@linaro.org>
L:	linux-pm@vger.kernel.org
S:	Supported
F:	drivers/cpuidle/dt_idle_genpd.c
F:	drivers/cpuidle/dt_idle_genpd.h

CPUIDLE DRIVER - RISC-V SBI
M:	Anup Patel <anup@brainfault.org>
L:	linux-pm@vger.kernel.org
L:	linux-riscv@lists.infradead.org
S:	Maintained
F:	drivers/cpuidle/cpuidle-riscv-sbi.c

CRAMFS FILESYSTEM
M:	Nicolas Pitre <nico@fluxnic.net>
S:	Maintained
F:	Documentation/filesystems/cramfs.rst
F:	fs/cramfs/

CREATIVE SB0540
M:	Bastien Nocera <hadess@hadess.net>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/hid-creative-sb0540.c

CRYPTO API
M:	Herbert Xu <herbert@gondor.apana.org.au>
M:	"David S. Miller" <davem@davemloft.net>
L:	linux-crypto@vger.kernel.org
S:	Maintained
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
F:	Documentation/crypto/
F:	Documentation/devicetree/bindings/crypto/
F:	arch/*/crypto/
F:	crypto/
F:	drivers/crypto/
F:	include/crypto/
F:	include/linux/crypto*
F:	lib/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
S:	Odd Fixes
W:	http://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/cs3308.c

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

CSI DRIVERS FOR ALLWINNER V3s
M:	Yong Deng <yong.deng@magewell.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/allwinner,sun6i-a31-csi.yaml
F:	drivers/media/platform/sunxi/sun6i-csi/

CTU CAN FD DRIVER
M:	Pavel Pisa <pisa@cmp.felk.cvut.cz>
M:	Ondrej Ille <ondrej.ille@gmail.com>
L:	linux-can@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/can/ctu,ctucanfd.yaml
F:	drivers/net/can/ctucanfd/

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:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/common/cx2341x*
F:	include/media/drv-intf/cx2341x.h

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

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

CXD2820R MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/cxd2820r*

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

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

CXGB4 CRYPTO DRIVER (chcr)
M:	Ayush Sawal <ayush.sawal@chelsio.com>
M:	Vinay Kumar Yadav <vinay.yadav@chelsio.com>
M:	Rohit Maheshwari <rohitm@chelsio.com>
L:	linux-crypto@vger.kernel.org
S:	Supported
W:	http://www.chelsio.com
F:	drivers/crypto/chelsio

CXGB4 INLINE CRYPTO DRIVER
M:	Ayush Sawal <ayush.sawal@chelsio.com>
M:	Vinay Kumar Yadav <vinay.yadav@chelsio.com>
M:	Rohit Maheshwari <rohitm@chelsio.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.chelsio.com
F:	drivers/net/ethernet/chelsio/inline_crypto/

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

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

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

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

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

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

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

CYCLADES PC300 DRIVER
S:	Orphan
F:	drivers/net/wan/pc300*

CYPRESS_FIRMWARE MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/common/cypress_firmware*

CYPRESS CY8CTMA140 TOUCHSCREEN DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/input/touchscreen/cy8ctma140.c

CYPRESS STREETFIGHTER TOUCHKEYS DRIVER
M:	Yassine Oudjana <y.oudjana@protonmail.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/input/cypress-sf.yaml
F:	drivers/input/keyboard/cypress-sf.c

CYTTSP TOUCHSCREEN DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/input/touchscreen/cyttsp*

D-LINK DIR-685 TOUCHKEYS DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-input@vger.kernel.org
S:	Supported
F:	drivers/input/keyboard/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>
L:	linux-hams@vger.kernel.org
S:	Maintained
W:	http://yaina.de/jreuter/
W:	http://www.qsl.net/dl1bke/
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

DATA ACCESS MONITOR
M:	SeongJae Park <sj@kernel.org>
L:	damon@lists.linux.dev
L:	linux-mm@kvack.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-kernel-mm-damon
F:	Documentation/admin-guide/mm/damon/
F:	Documentation/vm/damon/
F:	include/linux/damon.h
F:	include/trace/events/damon.h
F:	mm/damon/
F:	tools/testing/selftests/damon/

DAVICOM FAST ETHERNET (DMFE) NETWORK DRIVER
L:	netdev@vger.kernel.org
S:	Orphan
F:	Documentation/networking/device_drivers/ethernet/dec/dmfe.rst
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
S:	Maintained
W:	http://twibble.org/dist/dc395x/
W:	http://lists.twibble.org/mailman/listinfo/dc395x/
F:	Documentation/scsi/dc395x.rst
F:	drivers/scsi/dc395x.*

DCCP PROTOCOL
L:	dccp@vger.kernel.org
S:	Orphan
W:	http://www.linuxfoundation.org/collaborate/workgroups/networking/dccp
F:	include/linux/dccp.h
F:	include/linux/tfrc.h
F:	include/uapi/linux/dccp.h
F:	net/dccp/

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

DECSTATION PLATFORM SUPPORT
M:	"Maciej W. Rozycki" <macro@orcam.me.uk>
L:	linux-mips@vger.kernel.org
S:	Maintained
W:	http://www.linux-mips.org/wiki/DECstation
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@orcam.me.uk>
S:	Maintained
F:	drivers/net/fddi/defxx.*

DEFZA FDDI NETWORK DRIVER
M:	"Maciej W. Rozycki" <macro@orcam.me.uk>
S:	Maintained
F:	drivers/net/fddi/defza.*

DEINTERLACE DRIVERS FOR ALLWINNER H3
M:	Jernej Skrabec <jernej.skrabec@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/allwinner,sun8i-h3-deinterlace.yaml
F:	drivers/media/platform/sunxi/sun8i-di/

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

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

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

DELL LAPTOP SMM DRIVER
M:	Pali Rohár <pali@kernel.org>
S:	Maintained
F:	Documentation/ABI/obsolete/procfs-i8k
F:	drivers/hwmon/dell-smm-hwmon.c
F:	include/uapi/linux/i8k.h

DELL REMOTE BIOS UPDATE DRIVER
M:	Stuart Hayes <stuart.w.hayes@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/dell/dell_rbu.c

DELL SMBIOS DRIVER
M:	Pali Rohár <pali@kernel.org>
L:	Dell.Client.Kernel@dell.com
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/dell/dell-smbios.*

DELL SMBIOS SMM DRIVER
L:	Dell.Client.Kernel@dell.com
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/dell/dell-smbios-smm.c

DELL SMBIOS WMI DRIVER
L:	Dell.Client.Kernel@dell.com
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/dell/dell-smbios-wmi.c
F:	tools/wmi/dell-smbios-example.c

DELL SYSTEMS MANAGEMENT BASE DRIVER (dcdbas)
M:	Stuart Hayes <stuart.w.hayes@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	Documentation/driver-api/dcdbas.rst
F:	drivers/platform/x86/dell/dcdbas.*

DELL WMI DESCRIPTOR DRIVER
L:	Dell.Client.Kernel@dell.com
S:	Maintained
F:	drivers/platform/x86/dell/dell-wmi-descriptor.c

DELL WMI SYSMAN DRIVER
M:	Divya Bharathi <divya.bharathi@dell.com>
M:	Prasanth Ksr <prasanth.ksr@dell.com>
L:	Dell.Client.Kernel@dell.com
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-class-firmware-attributes
F:	drivers/platform/x86/dell/dell-wmi-sysman/

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

DELL WMI HARDWARE PRIVACY SUPPORT
M:	Perry Yuan <Perry.Yuan@dell.com>
L:	Dell.Client.Kernel@dell.com
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/dell/dell-wmi-privacy.c

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

DELTA AHE-50DC FAN CONTROL MODULE DRIVER
M:	Zev Weiss <zev@bewilderbeest.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	drivers/hwmon/pmbus/delta-ahe50dc-fan.c

DELTA DPS920AB PSU DRIVER
M:	Robert Marko <robert.marko@sartura.hr>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/dps920ab.rst
F:	drivers/hwmon/pmbus/dps920ab.c

DELTA NETWORKS TN48M CPLD DRIVERS
M:	Robert Marko <robert.marko@sartura.hr>
S:	Maintained
F:	Documentation/devicetree/bindings/gpio/delta,tn48m-gpio.yaml
F:	Documentation/devicetree/bindings/mfd/delta,tn48m-cpld.yaml
F:	Documentation/devicetree/bindings/reset/delta,tn48m-reset.yaml
F:	drivers/gpio/gpio-tn48m.c
F:	include/dt-bindings/reset/delta,tn48m-reset.h

DENALI NAND DRIVER
L:	linux-mtd@lists.infradead.org
S:	Orphan
F:	drivers/mtd/nand/raw/denali*

DESIGNWARE EDMA CORE IP DRIVER
M:	Gustavo Pimentel <gustavo.pimentel@synopsys.com>
L:	dmaengine@vger.kernel.org
S:	Maintained
F:	drivers/dma/dw-edma/
F:	include/linux/dma/edma.h

DESIGNWARE XDATA IP DRIVER
M:	Gustavo Pimentel <gustavo.pimentel@synopsys.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/misc-devices/dw-xdata-pcie.rst
F:	drivers/misc/dw-xdata-pcie.c

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

DESIGNWARE USB3 DRD IP DRIVER
M:	Felipe Balbi <balbi@kernel.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb.git
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 DEPENDENCY HELPER SCRIPT
M:	Saravana Kannan <saravanak@google.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	scripts/dev-needs.sh

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

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

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

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

DEVICE RESOURCE MANAGEMENT HELPERS
M:	Hans de Goede <hdegoede@redhat.com>
R:	Matti Vaittinen <mazziesaccount@gmail.com>
S:	Maintained
F:	include/linux/devm-helpers.h

DEVICE-MAPPER  (LVM)
M:	Alasdair Kergon <agk@redhat.com>
M:	Mike Snitzer <snitzer@kernel.org>
M:	dm-devel@redhat.com
L:	dm-devel@redhat.com
S:	Maintained
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/
F:	Documentation/admin-guide/device-mapper/
F:	drivers/md/Kconfig
F:	drivers/md/Makefile
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@nvidia.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/devlink
F:	include/net/devlink.h
F:	include/uapi/linux/devlink.h
F:	net/core/devlink.c

DH ELECTRONICS IMX6 DHCOM BOARD SUPPORT
M:	Christoph Niedermaier <cniedermaier@dh-electronics.com>
L:	kernel@dh-electronics.com
S:	Maintained
F:	arch/arm/boot/dts/imx6*-dhcom-*

DH ELECTRONICS STM32MP1 DHCOM/DHCOR BOARD SUPPORT
M:	Marek Vasut <marex@denx.de>
L:	kernel@dh-electronics.com
S:	Maintained
F:	arch/arm/boot/dts/stm32mp1*-dhcom-*
F:	arch/arm/boot/dts/stm32mp1*-dhcor-*

DIALOG SEMICONDUCTOR DRIVERS
M:	Support Opensource <support.opensource@diasemi.com>
S:	Supported
W:	http://www.dialog-semiconductor.com/products
F:	Documentation/devicetree/bindings/input/da90??-onkey.txt
F:	Documentation/devicetree/bindings/input/dlg,da72??.txt
F:	Documentation/devicetree/bindings/mfd/da90*.txt
F:	Documentation/devicetree/bindings/regulator/dlg,da9*.yaml
F:	Documentation/devicetree/bindings/regulator/da92*.txt
F:	Documentation/devicetree/bindings/regulator/slg51000.txt
F:	Documentation/devicetree/bindings/sound/da[79]*.txt
F:	Documentation/devicetree/bindings/thermal/da90??-thermal.txt
F:	Documentation/devicetree/bindings/watchdog/da90??-wdt.txt
F:	Documentation/hwmon/da90??.rst
F:	drivers/gpio/gpio-da90??.c
F:	drivers/hwmon/da90??-hwmon.c
F:	drivers/iio/adc/da91??-*.c
F:	drivers/input/misc/da72??.[ch]
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/pinctrl/pinctrl-da90??.c
F:	drivers/power/supply/da9052-battery.c
F:	drivers/power/supply/da91??-*.c
F:	drivers/regulator/da9???-regulator.[ch]
F:	drivers/regulator/slg51000-regulator.[ch]
F:	drivers/rtc/rtc-da90??.c
F:	drivers/thermal/da90??-thermal.c
F:	drivers/video/backlight/da90??_bl.c
F:	drivers/watchdog/da90??_wdt.c
F:	include/dt-bindings/regulator/dlg,da9*-regulator.h
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 <william.gray@linaro.org>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-gpio-mm.c

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

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.rst
F:	fs/notify/dnotify/
F:	include/linux/dnotify.h

DISK GEOMETRY AND PARTITION HANDLING
M:	Andries Brouwer <aeb@cwi.nl>
S:	Maintained
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

DISKQUOTA
M:	Jan Kara <jack@suse.com>
S:	Maintained
F:	Documentation/filesystems/quota.rst
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:	Documentation/fb/udlfb.rst
F:	drivers/video/fbdev/udlfb.c
F:	include/video/udlfb.h

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

DMA BUFFER SHARING FRAMEWORK
M:	Sumit Semwal <sumit.semwal@linaro.org>
M:	Christian König <christian.koenig@amd.com>
L:	linux-media@vger.kernel.org
L:	dri-devel@lists.freedesktop.org
L:	linaro-mm-sig@lists.linaro.org (moderated for non-subscribers)
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/driver-api/dma-buf.rst
F:	drivers/dma-buf/
F:	include/linux/*fence.h
F:	include/linux/dma-buf.h
F:	include/linux/dma-resv.h
K:	\bdma_(?:buf|fence|resv)\b

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

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.dev
S:	Supported
W:	http://git.infradead.org/users/hch/dma-mapping.git
T:	git git://git.infradead.org/users/hch/dma-mapping.git
F:	include/asm-generic/dma-mapping.h
F:	include/linux/dma-direct.h
F:	include/linux/dma-mapping.h
F:	include/linux/dma-map-ops.h
F:	kernel/dma/

DMA MAPPING BENCHMARK
M:	Xiang Chen <chenxiang66@hisilicon.com>
L:	iommu@lists.linux.dev
F:	kernel/dma/map_benchmark.c
F:	tools/testing/selftests/dma/

DMA-BUF HEAPS FRAMEWORK
M:	Sumit Semwal <sumit.semwal@linaro.org>
R:	Benjamin Gaignard <benjamin.gaignard@collabora.com>
R:	Liam Mark <lmark@codeaurora.org>
R:	Laura Abbott <labbott@redhat.com>
R:	Brian Starkey <Brian.Starkey@arm.com>
R:	John Stultz <jstultz@google.com>
L:	linux-media@vger.kernel.org
L:	dri-devel@lists.freedesktop.org
L:	linaro-mm-sig@lists.linaro.org (moderated for non-subscribers)
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/dma-buf/dma-heap.c
F:	drivers/dma-buf/heaps/*
F:	include/linux/dma-heap.h
F:	include/uapi/linux/dma-heap.h

DMC FREQUENCY DRIVER FOR SAMSUNG EXYNOS5422
M:	Lukasz Luba <lukasz.luba@arm.com>
L:	linux-pm@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/memory-controllers/samsung,exynos5422-dmc.yaml
F:	drivers/memory/samsung/exynos5422-dmc.c

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

DMI/SMBIOS SUPPORT
M:	Jean Delvare <jdelvare@suse.com>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jdelvare/staging.git dmi-for-next
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
P:	Documentation/doc-guide/maintainer-profile.rst
T:	git git://git.lwn.net/linux.git docs-next
F:	Documentation/
F:	scripts/documentation-file-ref-check
F:	scripts/kernel-doc
F:	scripts/sphinx-pre-install
X:	Documentation/ABI/
X:	Documentation/admin-guide/media/
X:	Documentation/devicetree/
X:	Documentation/driver-api/media/
X:	Documentation/firmware-guide/acpi/
X:	Documentation/i2c/
X:	Documentation/power/
X:	Documentation/spi/
X:	Documentation/userspace-api/media/

DOCUMENTATION REPORTING ISSUES
M:	Thorsten Leemhuis <linux@leemhuis.info>
L:	linux-doc@vger.kernel.org
S:	Maintained
F:	Documentation/admin-guide/reporting-issues.rst

DOCUMENTATION SCRIPTS
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-doc@vger.kernel.org
S:	Maintained
F:	Documentation/sphinx/parse-headers.pl
F:	scripts/documentation-file-ref-check
F:	scripts/sphinx-pre-install

DOCUMENTATION/ITALIAN
M:	Federico Vaga <federico.vaga@vaga.pv.it>
L:	linux-doc@vger.kernel.org
S:	Maintained
F:	Documentation/translations/it_IT

DOCUMENTATION/JAPANESE
R:	Akira Yokosawa <akiyks@gmail.com>
L:	linux-doc@vger.kernel.org
S:	Maintained
F:	Documentation/translations/ja_JP

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

DONGWOON DW9768 LENS VOICE COIL DRIVER
M:	Dongchun Zhu <dongchun.zhu@mediatek.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/dongwoon,dw9768.yaml
F:	drivers/media/i2c/dw9768.c

DONGWOON DW9807 LENS VOICE COIL DRIVER
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/dongwoon,dw9807-vcm.yaml
F:	drivers/media/i2c/dw9807-vcm.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/soc/fsl/dpio

DPAA2 ETHERNET DRIVER
M:	Ioana Ciornei <ioana.ciornei@nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/networking/device_drivers/ethernet/freescale/dpaa2/ethernet-driver.rst
F:	Documentation/networking/device_drivers/ethernet/freescale/dpaa2/mac-phy-support.rst
F:	drivers/net/ethernet/freescale/dpaa2/Kconfig
F:	drivers/net/ethernet/freescale/dpaa2/Makefile
F:	drivers/net/ethernet/freescale/dpaa2/dpaa2-eth*
F:	drivers/net/ethernet/freescale/dpaa2/dpaa2-mac*
F:	drivers/net/ethernet/freescale/dpaa2/dpkg.h
F:	drivers/net/ethernet/freescale/dpaa2/dpmac*
F:	drivers/net/ethernet/freescale/dpaa2/dpni*

DPAA2 ETHERNET SWITCH DRIVER
M:	Ioana Ciornei <ioana.ciornei@nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/networking/device_drivers/ethernet/freescale/dpaa2/switch-driver.rst
F:	drivers/net/ethernet/freescale/dpaa2/dpaa2-switch*
F:	drivers/net/ethernet/freescale/dpaa2/dpsw*

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

DRIVER COMPONENT FRAMEWORK
L:	dri-devel@lists.freedesktop.org
F:	drivers/base/component.c
F:	include/linux/component.h

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

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

DRM DRIVER FOR ALLWINNER DE2 AND DE3 ENGINE
M:	Maxime Ripard <mripard@kernel.org>
M:	Chen-Yu Tsai <wens@csie.org>
R:	Jernej Skrabec <jernej.skrabec@gmail.com>
L:	dri-devel@lists.freedesktop.org
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/sun4i/sun8i*

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

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

DRM DRIVER FOR ASPEED BMC GFX
M:	Joel Stanley <joel@jms.id.au>
L:	linux-aspeed@lists.ozlabs.org (moderated for non-subscribers)
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/gpu/aspeed-gfx.txt
F:	drivers/gpu/drm/aspeed/

DRM DRIVER FOR AST SERVER GRAPHICS CHIPS
M:	Dave Airlie <airlied@redhat.com>
R:	Thomas Zimmermann <tzimmermann@suse.de>
L:	dri-devel@lists.freedesktop.org
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/ast/

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

DRM DRIVER FOR BOE HIMAX8279D PANELS
M:	Jerry Han <hanxu5@huaqin.corp-partner.google.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/panel/boe,himax8279d.yaml
F:	drivers/gpu/drm/panel/panel-boe-himax8279d.c

DRM DRIVER FOR CHIPONE ICN6211 MIPI-DSI to RGB CONVERTER BRIDGE
M:	Jagan Teki <jagan@amarulasolutions.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/bridge/chipone,icn6211.yaml
F:	drivers/gpu/drm/bridge/chipone-icn6211.c

DRM DRIVER FOR EBBG FT8719 PANEL
M:	Joel Selvaraj <jo@jsfamily.in>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/panel/ebbg,ft8719.yaml
F:	drivers/gpu/drm/panel/panel-ebbg-ft8719.c

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

DRM DRIVER FOR FEIXIN K101 IM2BA02 MIPI-DSI LCD PANELS
M:	Icenowy Zheng <icenowy@aosc.io>
S:	Maintained
F:	Documentation/devicetree/bindings/display/panel/feixin,k101-im2ba02.yaml
F:	drivers/gpu/drm/panel/panel-feixin-k101-im2ba02.c

DRM DRIVER FOR FEIYANG FY07024DI26A30-D MIPI-DSI LCD PANELS
M:	Jagan Teki <jagan@amarulasolutions.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/panel/feiyang,fy07024di26a30d.yaml
F:	drivers/gpu/drm/panel/panel-feiyang-fy07024di26a30d.c

DRM DRIVER FOR GENERIC USB DISPLAY
M:	Noralf Trønnes <noralf@tronnes.org>
S:	Maintained
W:	https://github.com/notro/gud/wiki
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/gud/
F:	include/drm/gud.h

DRM DRIVER FOR GRAIN MEDIA GM12U320 PROJECTORS
M:	Hans de Goede <hdegoede@redhat.com>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/tiny/gm12u320.c

DRM DRIVER FOR HX8357D PANELS
M:	Emma Anholt <emma@anholt.net>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/himax,hx8357d.txt
F:	drivers/gpu/drm/tiny/hx8357d.c

DRM DRIVER FOR ILITEK ILI9225 PANELS
M:	David Lechner <david@lechnology.com>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/ilitek,ili9225.txt
F:	drivers/gpu/drm/tiny/ili9225.c

DRM DRIVER FOR ILITEK ILI9486 PANELS
M:	Kamlesh Gurudasani <kamlesh.gurudasani@gmail.com>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/ilitek,ili9486.yaml
F:	drivers/gpu/drm/tiny/ili9486.c

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 LOGICVC DISPLAY CONTROLLER
M:	Paul Kocialkowski <paul.kocialkowski@bootlin.com>
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/logicvc/

DRM DRIVER FOR LVDS PANELS
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	dri-devel@lists.freedesktop.org
T:	git git://anongit.freedesktop.org/drm/drm-misc
S:	Maintained
F:	drivers/gpu/drm/panel/panel-lvds.c
F:	Documentation/devicetree/bindings/display/lvds.yaml
F:	Documentation/devicetree/bindings/display/panel/panel-lvds.yaml

DRM DRIVER FOR MANTIX MLAF057WE51 PANELS
M:	Guido Günther <agx@sigxcpu.org>
R:	Purism Kernel Team <kernel@puri.sm>
S:	Maintained
F:	Documentation/devicetree/bindings/display/panel/mantix,mlaf057we51-x.yaml
F:	drivers/gpu/drm/panel/panel-mantix-mlaf057we51.c

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 GRAPHICS CHIPS
M:	Dave Airlie <airlied@redhat.com>
R:	Thomas Zimmermann <tzimmermann@suse.de>
L:	dri-devel@lists.freedesktop.org
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/mgag200/

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

DRM DRIVER FOR MIPI DBI compatible panels
M:	Noralf Trønnes <noralf@tronnes.org>
S:	Maintained
W:	https://github.com/notro/panel-mipi-dbi/wiki
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/panel/panel-mipi-dbi-spi.yaml
F:	drivers/gpu/drm/tiny/panel-mipi-dbi.c

DRM DRIVER FOR MSM ADRENO GPU
M:	Rob Clark <robdclark@gmail.com>
M:	Abhinav Kumar <quic_abhinavk@quicinc.com>
M:	Dmitry Baryshkov <dmitry.baryshkov@linaro.org>
R:	Sean Paul <sean@poorly.run>
L:	linux-arm-msm@vger.kernel.org
L:	dri-devel@lists.freedesktop.org
L:	freedreno@lists.freedesktop.org
S:	Maintained
T:	git https://gitlab.freedesktop.org/drm/msm.git
F:	Documentation/devicetree/bindings/display/msm/
F:	drivers/gpu/drm/msm/
F:	include/uapi/drm/msm_drm.h

DRM DRIVER FOR NOVATEK NT35510 PANELS
M:	Linus Walleij <linus.walleij@linaro.org>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/panel/novatek,nt35510.yaml
F:	drivers/gpu/drm/panel/panel-novatek-nt35510.c

DRM DRIVER FOR NOVATEK NT35560 PANELS
M:	Linus Walleij <linus.walleij@linaro.org>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/panel/sony,acx424akp.yaml
F:	drivers/gpu/drm/panel/panel-novatek-nt35560.c

DRM DRIVER FOR NOVATEK NT36672A PANELS
M:	Sumit Semwal <sumit.semwal@linaro.org>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/panel/novatek,nt36672a.yaml
F:	drivers/gpu/drm/panel/panel-novatek-nt36672a.c

DRM DRIVER FOR NVIDIA GEFORCE/QUADRO GPUS
M:	Ben Skeggs <bskeggs@redhat.com>
M:	Karol Herbst <kherbst@redhat.com>
M:	Lyude Paul <lyude@redhat.com>
L:	dri-devel@lists.freedesktop.org
L:	nouveau@lists.freedesktop.org
S:	Supported
W:	https://nouveau.freedesktop.org/
Q:	https://patchwork.freedesktop.org/project/nouveau/
Q:	https://gitlab.freedesktop.org/drm/nouveau/-/merge_requests
B:	https://gitlab.freedesktop.org/drm/nouveau/-/issues
C:	irc://irc.oftc.net/nouveau
T:	git https://gitlab.freedesktop.org/drm/nouveau.git
F:	drivers/gpu/drm/nouveau/
F:	include/uapi/drm/nouveau_drm.h

DRM DRIVER FOR OLIMEX LCD-OLINUXINO PANELS
M:	Stefan Mavrodiev <stefan@olimex.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/panel/olimex,lcd-olinuxino.yaml
F:	drivers/gpu/drm/panel/panel-olimex-lcd-olinuxino.c

DRM DRIVER FOR PARADE PS8640 BRIDGE CHIP
R:	Douglas Anderson <dianders@chromium.org>
F:	Documentation/devicetree/bindings/display/bridge/ps8640.yaml
F:	drivers/gpu/drm/bridge/parade-ps8640.c

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

DRM DRIVER FOR SOLOMON SSD130X OLED DISPLAYS
M:	Javier Martinez Canillas <javierm@redhat.com>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/solomon,ssd1307fb.yaml
F:	drivers/gpu/drm/solomon/ssd130x*

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
S:	Obsolete
W:	https://www.kraxel.org/blog/2014/10/qemu-using-cirrus-considered-harmful/
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/tiny/cirrus.c

DRM DRIVER FOR QXL VIRTUAL GPU
M:	Dave Airlie <airlied@redhat.com>
M:	Gerd Hoffmann <kraxel@redhat.com>
L:	virtualization@lists.linux-foundation.org
L:	spice-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
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 RAYDIUM RM67191 PANELS
M:	Robert Chiras <robert.chiras@nxp.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/panel/raydium,rm67191.yaml
F:	drivers/gpu/drm/panel/panel-raydium-rm67191.c

DRM DRIVER FOR SAMSUNG DB7430 PANELS
M:	Linus Walleij <linus.walleij@linaro.org>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/panel/samsung,lms397kf04.yaml
F:	drivers/gpu/drm/panel/panel-samsung-db7430.c

DRM DRIVER FOR SAMSUNG S6D27A1 PANELS
M:	Markuss Broks <markuss.broks@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/panel/samsung,s6d27a1.yaml
F:	drivers/gpu/drm/panel/panel-samsung-s6d27a1.c

DRM DRIVER FOR SITRONIX ST7703 PANELS
M:	Guido Günther <agx@sigxcpu.org>
R:	Purism Kernel Team <kernel@puri.sm>
R:	Ondrej Jirman <megous@megous.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/panel/rocktech,jh057n00900.yaml
F:	drivers/gpu/drm/panel/panel-sitronix-st7703.c

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

DRM DRIVER FOR FIRMWARE FRAMEBUFFERS
M:	Thomas Zimmermann <tzimmermann@suse.de>
M:	Javier Martinez Canillas <javierm@redhat.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/drm_aperture.c
F:	drivers/gpu/drm/tiny/simpledrm.c
F:	drivers/video/aperture.c
F:	include/drm/drm_aperture.h
F:	include/linux/aperture.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
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/sitronix,st7586.txt
F:	drivers/gpu/drm/tiny/st7586.c

DRM DRIVER FOR SITRONIX ST7701 PANELS
M:	Jagan Teki <jagan@amarulasolutions.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/panel/sitronix,st7701.yaml
F:	drivers/gpu/drm/panel/panel-sitronix-st7701.c

DRM DRIVER FOR SITRONIX ST7735R PANELS
M:	David Lechner <david@lechnology.com>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/sitronix,st7735r.yaml
F:	drivers/gpu/drm/tiny/st7735r.c

DRM DRIVER FOR ST-ERICSSON MCDE
M:	Linus Walleij <linus.walleij@linaro.org>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/ste,mcde.yaml
F:	drivers/gpu/drm/mcde/

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

DRM DRIVER FOR TI DLPC3433 MIPI DSI TO DMD BRIDGE
M:	Jagan Teki <jagan@amarulasolutions.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/bridge/ti,dlpc3433.yaml
F:	drivers/gpu/drm/bridge/ti-dlpc3433.c

DRM DRIVER FOR TI SN65DSI86 BRIDGE CHIP
R:	Douglas Anderson <dianders@chromium.org>
F:	Documentation/devicetree/bindings/display/bridge/ti,sn65dsi86.yaml
F:	drivers/gpu/drm/bridge/ti-sn65dsi86.c

DRM DRIVER FOR TPO TPG110 PANELS
M:	Linus Walleij <linus.walleij@linaro.org>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/panel/tpo,tpg110.yaml
F:	drivers/gpu/drm/panel/panel-tpo-tpg110.c

DRM DRIVER FOR USB DISPLAYLINK VIDEO ADAPTERS
M:	Dave Airlie <airlied@redhat.com>
R:	Sean Paul <sean@poorly.run>
R:	Thomas Zimmermann <tzimmermann@suse.de>
L:	dri-devel@lists.freedesktop.org
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/udl/

DRM DRIVER FOR VIRTUAL KERNEL MODESETTING (VKMS)
M:	Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
M:	Melissa Wen <melissa.srw@gmail.com>
R:	Haneen Mohammed <hamohammed.sa@gmail.com>
R:	Daniel Vetter <daniel@ffwll.ch>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/gpu/vkms.rst
F:	drivers/gpu/drm/vkms/

DRM DRIVER FOR VIRTUALBOX VIRTUAL GPU
M:	Hans de Goede <hdegoede@redhat.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/vboxvideo/

DRM DRIVER FOR VMWARE VIRTUAL GPU
M:	Zack Rusin <zackr@vmware.com>
R:	VMware Graphics Reviewers <linux-graphics-maintainer@vmware.com>
L:	dri-devel@lists.freedesktop.org
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/vmwgfx/
F:	include/uapi/drm/vmwgfx_drm.h

DRM DRIVER FOR WIDECHIPS WS2401 PANELS
M:	Linus Walleij <linus.walleij@linaro.org>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/panel/samsung,lms380kf01.yaml
F:	drivers/gpu/drm/panel/panel-widechips-ws2401.c

DRM DRIVERS
M:	David Airlie <airlied@linux.ie>
M:	Daniel Vetter <daniel@ffwll.ch>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
B:	https://gitlab.freedesktop.org/drm
C:	irc://irc.oftc.net/dri-devel
T:	git git://anongit.freedesktop.org/drm/drm
F:	Documentation/devicetree/bindings/display/
F:	Documentation/devicetree/bindings/gpu/
F:	Documentation/gpu/
F:	drivers/gpu/
F:	include/drm/
F:	include/linux/vga*
F:	include/uapi/drm/

DRM DRIVERS AND MISC GPU PATCHES
M:	Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
M:	Maxime Ripard <mripard@kernel.org>
M:	Thomas Zimmermann <tzimmermann@suse.de>
S:	Maintained
W:	https://01.org/linuxgraphics/gfx-docs/maintainer-tools/drm-misc.html
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/gpu/
F:	drivers/gpu/drm/*
F:	drivers/gpu/vga/
F:	include/drm/drm*
F:	include/linux/vga*
F:	include/uapi/drm/drm*

DRM DRIVERS FOR ALLWINNER A10
M:	Maxime Ripard <mripard@kernel.org>
M:	Chen-Yu Tsai <wens@csie.org>
L:	dri-devel@lists.freedesktop.org
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/allwinner*
F:	drivers/gpu/drm/sun4i/

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

DRM DRIVERS FOR ATMEL HLCDC
M:	Sam Ravnborg <sam@ravnborg.org>
M:	Boris Brezillon <bbrezillon@kernel.org>
L:	dri-devel@lists.freedesktop.org
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/atmel/
F:	drivers/gpu/drm/atmel-hlcdc/

DRM DRIVERS FOR BRIDGE CHIPS
M:	Andrzej Hajda <andrzej.hajda@intel.com>
M:	Neil Armstrong <narmstrong@baylibre.com>
M:	Robert Foss <robert.foss@linaro.org>
R:	Laurent Pinchart <Laurent.pinchart@ideasonboard.com>
R:	Jonas Karlman <jonas@kwiboo.se>
R:	Jernej Skrabec <jernej.skrabec@gmail.com>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/bridge/
F:	drivers/gpu/drm/bridge/

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

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
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/fsl,dcu.txt
F:	Documentation/devicetree/bindings/display/fsl,tcon.txt
F:	drivers/gpu/drm/fsl-dcu/

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

DRM DRIVERS FOR FREESCALE IMX BRIDGE
M:	Liu Ying <victor.liu@nxp.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	Documentation/devicetree/bindings/display/bridge/fsl,imx8qxp-ldb.yaml
F:	Documentation/devicetree/bindings/display/bridge/fsl,imx8qxp-pixel-combiner.yaml
F:	Documentation/devicetree/bindings/display/bridge/fsl,imx8qxp-pixel-link.yaml
F:	Documentation/devicetree/bindings/display/bridge/fsl,imx8qxp-pxl2dpi.yaml
F:	drivers/gpu/drm/bridge/imx/

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

DRM DRIVERS FOR HISILICON
M:	Xinliang Liu <xinliang.liu@linaro.org>
M:	Tian Tao  <tiantao6@hisilicon.com>
R:	John Stultz <jstultz@google.com>
R:	Xinwei Kong <kong.kongxinwei@hisilicon.com>
R:	Chen Feng <puck.chen@hisilicon.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/hisilicon/
F:	drivers/gpu/drm/hisilicon/

DRM DRIVER FOR HYPERV SYNTHETIC VIDEO DEVICE
M:	Deepak Rawat <drawat.floss@gmail.com>
L:	linux-hyperv@vger.kernel.org
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/hyperv

DRM DRIVERS FOR LIMA
M:	Qiang Yu <yuq825@gmail.com>
L:	dri-devel@lists.freedesktop.org
L:	lima@lists.freedesktop.org (moderated for non-subscribers)
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/lima/
F:	include/uapi/drm/lima_drm.h

DRM DRIVERS FOR MEDIATEK
M:	Chun-Kuang Hu <chunkuang.hu@kernel.org>
M:	Philipp Zabel <p.zabel@pengutronix.de>
L:	dri-devel@lists.freedesktop.org
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/display/mediatek/
F:	drivers/gpu/drm/mediatek/
F:	drivers/phy/mediatek/phy-mtk-dp.c
F:	drivers/phy/mediatek/phy-mtk-hdmi*
F:	drivers/phy/mediatek/phy-mtk-mipi*

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

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

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
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/rockchip/
F:	drivers/gpu/drm/rockchip/

DRM DRIVERS FOR STI
M:	Alain Volmat <alain.volmat@foss.st.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/st,stih4xx.txt
F:	drivers/gpu/drm/sti

DRM DRIVERS FOR STM
M:	Yannick Fertre <yannick.fertre@foss.st.com>
M:	Raphael Gallais-Pou <raphael.gallais-pou@foss.st.com>
M:	Philippe Cornu <philippe.cornu@foss.st.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/st,stm32-ltdc.yaml
F:	drivers/gpu/drm/stm

DRM DRIVERS FOR TI KEYSTONE
M:	Jyri Sarha <jyri.sarha@iki.fi>
M:	Tomi Valkeinen <tomba@kernel.org>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/ti/ti,am65x-dss.yaml
F:	Documentation/devicetree/bindings/display/ti/ti,j721e-dss.yaml
F:	Documentation/devicetree/bindings/display/ti/ti,k2g-dss.yaml
F:	drivers/gpu/drm/tidss/

DRM DRIVERS FOR TI LCDC
M:	Jyri Sarha <jyri.sarha@iki.fi>
R:	Tomi Valkeinen <tomba@kernel.org>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	Documentation/devicetree/bindings/display/tilcdc/
F:	drivers/gpu/drm/tilcdc/

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

DRM DRIVERS FOR V3D
M:	Emma Anholt <emma@anholt.net>
M:	Melissa Wen <mwen@igalia.com>
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/gpu/brcm,bcm-v3d.yaml
F:	drivers/gpu/drm/v3d/
F:	include/uapi/drm/v3d_drm.h

DRM DRIVERS FOR VC4
M:	Emma Anholt <emma@anholt.net>
M:	Maxime Ripard <mripard@kernel.org>
S:	Supported
T:	git git://github.com/anholt/linux
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/brcm,bcm2835-*.yaml
F:	drivers/gpu/drm/vc4/
F:	include/uapi/drm/vc4_drm.h

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 (moderated for non-subscribers)
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	Documentation/devicetree/bindings/gpu/vivante,gc.yaml
F:	drivers/gpu/drm/etnaviv/
F:	include/uapi/drm/etnaviv_drm.h

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

DRM DRIVERS FOR XILINX
M:	Hyun Kwon <hyun.kwon@xilinx.com>
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/xlnx/
F:	drivers/gpu/drm/xlnx/

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

DRM PRIVACY-SCREEN CLASS
M:	Hans de Goede <hdegoede@redhat.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/drm_privacy_screen*
F:	include/drm/drm_privacy_screen*

DRM TTM SUBSYSTEM
M:	Christian Koenig <christian.koenig@amd.com>
M:	Huang Rui <ray.huang@amd.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/ttm/
F:	include/drm/ttm/

DRM GPU SCHEDULER
M:	Andrey Grodzovsky <andrey.grodzovsky@amd.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/gpu/drm/scheduler/
F:	include/drm/gpu_scheduler.h

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

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

DVB_USB_AF9015 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
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
S:	Maintained
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
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
S:	Maintained
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
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
S:	Maintained
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
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
S:	Maintained
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
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
S:	Maintained
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
F:	drivers/media/usb/dvb-usb/cxusb*

DVB_USB_EC168 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
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
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/anttip/media_tree.git
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
S:	Maintained
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
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
S:	Maintained
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
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
S:	Maintained
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
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:	include/linux/dynamic_debug.h
F:	lib/dynamic_debug.c

DYNAMIC INTERRUPT MODERATION
M:	Tal Gilboa <talgi@nvidia.com>
S:	Maintained
F:	Documentation/networking/net_dim.rst
F:	include/linux/dim.h
F:	lib/dim/

DZ DECSTATION DZ11 SERIAL DRIVER
M:	"Maciej W. Rozycki" <macro@orcam.me.uk>
S:	Maintained
F:	drivers/tty/serial/dz.*

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

E4000 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/tuners/e4000*

EARTH_PT1 MEDIA DRIVER
M:	Akihiro Tsukada <tskd08@gmail.com>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
F:	drivers/media/pci/pt1/

EARTH_PT3 MEDIA DRIVER
M:	Akihiro Tsukada <tskd08@gmail.com>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
F:	drivers/media/pci/pt3/

EC100 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/ec100*

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

EDAC-AMD64
M:	Yazen Ghannam <yazen.ghannam@amd.com>
L:	linux-edac@vger.kernel.org
S:	Supported
F:	drivers/edac/amd64_edac*
F:	drivers/edac/mce_amd*

EDAC-ARMADA
M:	Jan Luebbe <jlu@pengutronix.de>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/memory-controllers/marvell,mvebu-sdram-controller.yaml
F:	drivers/edac/armada_xp_*

EDAC-AST2500
M:	Stefan Schaeckeler <sschaeck@cisco.com>
S:	Supported
F:	Documentation/devicetree/bindings/edac/aspeed-sdram-edac.txt
F:	drivers/edac/aspeed_edac.c

EDAC-BLUEFIELD
M:	Shravan Kumar Ramani <shravankr@nvidia.com>
S:	Supported
F:	drivers/edac/bluefield_edac.c

EDAC-CALXEDA
M:	Andre Przywara <andre.przywara@arm.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/highbank*

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

EDAC-CAVIUM THUNDERX
M:	Robert Richter <rric@kernel.org>
L:	linux-edac@vger.kernel.org
S:	Odd Fixes
F:	drivers/edac/thunderx_edac*

EDAC-CORE
M:	Borislav Petkov <bp@alien8.de>
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
M:	Tony Luck <tony.luck@intel.com>
R:	James Morse <james.morse@arm.com>
R:	Robert Richter <rric@kernel.org>
L:	linux-edac@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ras/ras.git edac-for-next
F:	Documentation/admin-guide/ras.rst
F:	Documentation/driver-api/edac.rst
F:	drivers/edac/
F:	include/linux/edac.h

EDAC-DMC520
M:	Lei Wang <lewan@microsoft.com>
L:	linux-edac@vger.kernel.org
S:	Supported
F:	drivers/edac/dmc520_edac.c

EDAC-E752X
M:	Mark Gross <markgross@kernel.org>
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-I10NM
M:	Tony Luck <tony.luck@intel.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/i10nm_base.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:	"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-IGEN6
M:	Tony Luck <tony.luck@intel.com>
R:	Qiuxu Zhuo <qiuxu.zhuo@intel.com>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/igen6_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-QCOM
M:	Channagoud Kadabi <ckadabi@codeaurora.org>
M:	Venkata Narendra Kumar Gutta <vnkgutta@codeaurora.org>
L:	linux-arm-msm@vger.kernel.org
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	drivers/edac/qcom_edac.c

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:	Tony Luck <tony.luck@intel.com>
R:	Qiuxu Zhuo <qiuxu.zhuo@intel.com>
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_*.[ch]

EDAC-TI
M:	Tero Kristo <kristo@kernel.org>
L:	linux-edac@vger.kernel.org
S:	Odd Fixes
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)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
F:	sound/usb/misc/ua101.c

EFI TEST DRIVER
M:	Ivan Hu <ivan.hu@canonical.com>
M:	Ard Biesheuvel <ardb@kernel.org>
L:	linux-efi@vger.kernel.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 <ardb@kernel.org>
L:	linux-efi@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/efi/efi.git
F:	fs/efivarfs/

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

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

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

ELM327 CAN NETWORK DRIVER
M:	Max Staudt <max@enpas.org>
L:	linux-can@vger.kernel.org
S:	Maintained
F:	Documentation/networking/device_drivers/can/can327.rst
F:	drivers/net/can/can327.c

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

EMBEDDED LINUX
M:	Olivia Mackall <olivia@selenic.com>
M:	David Woodhouse <dwmw2@infradead.org>
L:	linux-embedded@vger.kernel.org
S:	Maintained

EMMC CMDQ HOST CONTROLLER INTERFACE (CQHCI) DRIVER
M:	Adrian Hunter <adrian.hunter@intel.com>
M:	Ritesh Harjani <riteshh@codeaurora.org>
M:	Asutosh Das <asutoshd@codeaurora.org>
L:	linux-mmc@vger.kernel.org
S:	Maintained
F:	drivers/mmc/host/cqhci*

EMULEX 10Gbps iSCSI - OneConnect DRIVER
M:	Ketan Mukadam <ketan.mukadam@broadcom.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
W:	http://www.broadcom.com
F:	drivers/scsi/be2iscsi/

EMULEX 10Gbps NIC BE2, BE3-R, Lancer, Skyhawk-R DRIVER (be2net)
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
S:	Supported
W:	http://www.emulex.com
F:	drivers/net/ethernet/emulex/benet/

EMULEX ONECONNECT ROCE DRIVER
M:	Selvin Xavier <selvin.xavier@broadcom.com>
L:	linux-rdma@vger.kernel.org
S:	Odd Fixes
W:	http://www.broadcom.com
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
S:	Supported
W:	http://www.broadcom.com
F:	drivers/scsi/lpfc/

EMULEX/BROADCOM EFCT FC/FCOE SCSI TARGET DRIVER
M:	James Smart <james.smart@broadcom.com>
M:	Ram Vegesna <ram.vegesna@broadcom.com>
L:	linux-scsi@vger.kernel.org
L:	target-devel@vger.kernel.org
S:	Supported
W:	http://www.broadcom.com
F:	drivers/scsi/elx/

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.*

EPAPR HYPERVISOR BYTE CHANNEL DEVICE DRIVER
M:	Laurentiu Tudor <laurentiu.tudor@nxp.com>
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/tty/ehv_bytechan.c

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

EROFS FILE SYSTEM
M:	Gao Xiang <xiang@kernel.org>
M:	Chao Yu <chao@kernel.org>
R:	Yue Hu <huyue2@coolpad.com>
R:	Jeffle Xu <jefflexu@linux.alibaba.com>
L:	linux-erofs@lists.ozlabs.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/xiang/erofs.git
F:	Documentation/filesystems/erofs.rst
F:	fs/erofs/
F:	include/trace/events/erofs.h

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

ESD CAN/USB DRIVERS
M:	Frank Jungclaus <frank.jungclaus@esd.eu>
R:	socketcan@esd.eu
L:	linux-can@vger.kernel.org
S:	Maintained
F:	drivers/net/can/usb/esd_usb.c

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

ETAS ES58X CAN/USB DRIVER
M:	Vincent Mailhol <mailhol.vincent@wanadoo.fr>
L:	linux-can@vger.kernel.org
S:	Maintained
F:	drivers/net/can/usb/etas_es58x/

ETHERNET BRIDGE
M:	Roopa Prabhu <roopa@nvidia.com>
M:	Nikolay Aleksandrov <razor@blackwall.org>
L:	bridge@lists.linux-foundation.org (moderated for non-subscribers)
L:	netdev@vger.kernel.org
S:	Maintained
W:	http://www.linuxfoundation.org/en/Net:Bridge
F:	include/linux/netfilter_bridge/
F:	net/bridge/

ETHERNET PHY LIBRARY
M:	Andrew Lunn <andrew@lunn.ch>
M:	Heiner Kallweit <hkallweit1@gmail.com>
R:	Russell King <linux@armlinux.org.uk>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-class-net-phydev
F:	Documentation/devicetree/bindings/net/ethernet-phy.yaml
F:	Documentation/devicetree/bindings/net/mdio*
F:	Documentation/devicetree/bindings/net/qca,ar803x.yaml
F:	Documentation/networking/phy.rst
F:	drivers/net/mdio/
F:	drivers/net/mdio/acpi_mdio.c
F:	drivers/net/mdio/fwnode_mdio.c
F:	drivers/net/mdio/of_mdio.c
F:	drivers/net/pcs/
F:	drivers/net/phy/
F:	include/dt-bindings/net/qca-ar803x.h
F:	include/linux/linkmode.h
F:	include/linux/*mdio*.h
F:	include/linux/mdio/*.h
F:	include/linux/mii.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/linux/platform_data/mdio-gpio.h
F:	include/trace/events/mdio.h
F:	include/uapi/linux/mdio.h
F:	include/uapi/linux/mii.h
F:	net/core/of_net.c

EXEC & BINFMT API
R:	Eric Biederman <ebiederm@xmission.com>
R:	Kees Cook <keescook@chromium.org>
L:	linux-mm@kvack.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/execve
F:	arch/alpha/kernel/binfmt_loader.c
F:	fs/*binfmt_*.c
F:	fs/exec.c
F:	include/linux/binfmts.h
F:	include/linux/elf.h
F:	include/uapi/linux/binfmts.h
F:	include/uapi/linux/elf.h
F:	tools/testing/selftests/exec/
N:	asm/elf.h
N:	binfmt

EXFAT FILE SYSTEM
M:	Namjae Jeon <linkinjeon@kernel.org>
M:	Sungjong Seo <sj1557.seo@samsung.com>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	fs/exfat/

EXT2 FILE SYSTEM
M:	Jan Kara <jack@suse.com>
L:	linux-ext4@vger.kernel.org
S:	Maintained
F:	Documentation/filesystems/ext2.rst
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
S:	Maintained
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
F:	Documentation/filesystems/ext4/
F:	fs/ext4/
F:	include/trace/events/ext4.h

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

EXTENSIBLE FIRMWARE INTERFACE (EFI)
M:	Ard Biesheuvel <ardb@kernel.org>
L:	linux-efi@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/efi/efi.git
F:	Documentation/admin-guide/efi-stub.rst
F:	arch/*/include/asm/efi.h
F:	arch/*/kernel/efi.c
F:	arch/arm/boot/compressed/efi-header.S
F:	arch/arm64/kernel/efi-entry.S
F:	arch/x86/platform/efi/
F:	drivers/firmware/efi/
F:	include/linux/efi*.h

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

EXTRA BOOT CONFIG
M:	Masami Hiramatsu <mhiramat@kernel.org>
S:	Maintained
F:	Documentation/admin-guide/bootconfig.rst
F:	fs/proc/bootconfig.c
F:	include/linux/bootconfig.h
F:	lib/bootconfig-data.S
F:	lib/bootconfig.c
F:	tools/bootconfig/*
F:	tools/bootconfig/scripts/*

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.dev
S:	Maintained
F:	drivers/iommu/exynos-iommu.c

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

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

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

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

FANOTIFY
M:	Jan Kara <jack@suse.cz>
R:	Amir Goldstein <amir73il@gmail.com>
R:	Matthew Bobrowski <repnop@google.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>
S:	Supported
W:	http://www.farsite.co.uk/
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
L:	dri-devel@lists.freedesktop.org
L:	linux-fbdev@vger.kernel.org
S:	Orphan
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.c
F:	drivers/media/tuners/fc0011.h

FC2580 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/tuners/fc2580*

FCOE SUBSYSTEM (libfc, libfcoe, fcoe)
M:	Hannes Reinecke <hare@suse.de>
L:	linux-scsi@vger.kernel.org
S:	Supported
W:	www.Open-FCoE.org
F:	drivers/scsi/fcoe/
F:	drivers/scsi/libfc/
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:	Chuck Lever <chuck.lever@oracle.com>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	fs/fcntl.c
F:	fs/locks.c
F:	include/linux/fcntl.h
F:	include/uapi/linux/fcntl.h

FILESYSTEM DIRECT ACCESS (DAX)
M:	Dan Williams <dan.j.williams@intel.com>
R:	Matthew Wilcox <willy@infradead.org>
R:	Jan Kara <jack@suse.cz>
L:	linux-fsdevel@vger.kernel.org
L:	nvdimm@lists.linux.dev
S:	Supported
F:	fs/dax.c
F:	include/linux/dax.h
F:	include/trace/events/fs_dax.h

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/linux/fs_types.h
F:	include/uapi/linux/fs.h
F:	include/uapi/linux/openat2.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 and IEC 61883-1/6 PACKET STREAMING ENGINE
M:	Clemens Ladisch <clemens@ladisch.de>
M:	Takashi Sakamoto <o-takashi@sakamocchi.jp>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
F:	include/uapi/sound/firewire.h
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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media.git
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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nab/lio-core-2.6.git master
F:	drivers/target/sbp/

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

FIRMWARE FRAMEWORK FOR ARMV8-A
M:	Sudeep Holla <sudeep.holla@arm.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/firmware/arm_ffa/
F:	include/linux/arm_ffa.h

FIRMWARE LOADER (request_firmware)
M:	Luis Chamberlain <mcgrof@kernel.org>
M:	Russ Weight <russell.h.weight@intel.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/firmware_class/
F:	drivers/base/firmware_loader/
F:	include/linux/firmware.h

FLEXTIMER FTM-QUADDEC DRIVER
M:	Patrick Havelange <patrick.havelange@essensium.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/counter/ftm-quaddec.txt
F:	drivers/counter/ftm-quaddec.c

FLOPPY DRIVER
M:	Denis Efremov <efremov@linux.com>
L:	linux-block@vger.kernel.org
S:	Odd Fixes
F:	drivers/block/floppy.c

FLYSKY FSIA6B RC RECEIVER
M:	Markus Koch <markus@notsyncing.net>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/input/joystick/fsia6b.c

FOCUSRITE SCARLETT GEN 2/3 MIXER DRIVER
M:	Geoffrey D. Bennett <g@b4.vu>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
F:	sound/usb/mixer_scarlett_gen2.c

FORCEDETH GIGABIT ETHERNET DRIVER
M:	Rain River <rain.1986.08.12@gmail.com>
M:	Zhu Yanjun <zyjzyj2000@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/nvidia/*

FORTIFY_SOURCE
M:	Kees Cook <keescook@chromium.org>
L:	linux-hardening@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
F:	include/linux/fortify-string.h
F:	lib/test_fortify/*
F:	scripts/test_fortify.sh
K:	\b__NO_FORTIFY\b

FPGA DFL DRIVERS
M:	Wu Hao <hao.wu@intel.com>
R:	Tom Rix <trix@redhat.com>
L:	linux-fpga@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-dfl*
F:	Documentation/fpga/dfl.rst
F:	drivers/fpga/dfl*
F:	drivers/uio/uio_dfl.c
F:	include/linux/dfl.h
F:	include/uapi/linux/fpga-dfl.h

FPGA MANAGER FRAMEWORK
M:	Moritz Fischer <mdf@kernel.org>
M:	Wu Hao <hao.wu@intel.com>
M:	Xu Yilun <yilun.xu@intel.com>
R:	Tom Rix <trix@redhat.com>
L:	linux-fpga@vger.kernel.org
S:	Maintained
Q:	http://patchwork.kernel.org/project/linux-fpga/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/fpga/linux-fpga.git
F:	Documentation/devicetree/bindings/fpga/
F:	Documentation/driver-api/fpga/
F:	Documentation/fpga/
F:	drivers/fpga/
F:	include/linux/fpga/

INTEL MAX10 BMC SECURE UPDATES
M:	Russ Weight <russell.h.weight@intel.com>
L:	linux-fpga@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-driver-intel-m10-bmc-sec-update
F:	drivers/fpga/intel-m10-bmc-sec-update.c

MICROCHIP POLARFIRE FPGA DRIVERS
M:	Conor Dooley <conor.dooley@microchip.com>
R:	Ivan Bornyakov <i.bornyakov@metrotek.ru>
L:	linux-fpga@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/fpga/microchip,mpf-spi-fpga-mgr.yaml
F:	drivers/fpga/microchip-spi.c

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

FRAMEBUFFER CORE
M:	Daniel Vetter <daniel@ffwll.ch>
F:	drivers/video/fbdev/core/
S:	Odd Fixes
T:	git git://anongit.freedesktop.org/drm/drm-misc

FRAMEBUFFER LAYER
M:	Helge Deller <deller@gmx.de>
L:	linux-fbdev@vger.kernel.org
L:	dri-devel@lists.freedesktop.org
S:	Maintained
Q:	http://patchwork.kernel.org/project/linux-fbdev/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/deller/linux-fbdev.git
F:	Documentation/fb/
F:	drivers/video/
F:	include/linux/fb.h
F:	include/uapi/linux/fb.h
F:	include/uapi/video/
F:	include/video/

FREESCALE CAAM (Cryptographic Acceleration and Assurance Module) DRIVER
M:	Horia Geantă <horia.geanta@nxp.com>
M:	Pankaj Gupta <pankaj.gupta@nxp.com>
M:	Gaurav Jain <gaurav.jain@nxp.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/crypto/fsl-sec4.txt
F:	drivers/crypto/caam/

FREESCALE COLDFIRE M5441X MMC DRIVER
M:	Angelo Dureghello <angelo.dureghello@timesys.com>
L:	linux-mmc@vger.kernel.org
S:	Maintained
F:	drivers/mmc/host/sdhci-esdhc-mcf.c
F:	include/linux/platform_data/mmc-esdhc-mcf.h

FREESCALE DIU FRAMEBUFFER DRIVER
M:	Timur Tabi <timur@kernel.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 DSPI DRIVER
M:	Vladimir Oltean <olteanv@gmail.com>
L:	linux-spi@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/spi/spi-fsl-dspi.txt
F:	drivers/spi/spi-fsl-dspi.c
F:	include/linux/spi/spi-fsl-dspi.h

FREESCALE ENETC ETHERNET DRIVERS
M:	Claudiu Manoil <claudiu.manoil@nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/freescale/enetc/

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

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:	Joakim Zhang <qiangqing.zhang@nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/fsl,fec.yaml
F:	drivers/net/ethernet/freescale/fec.h
F:	drivers/net/ethernet/freescale/fec_main.c
F:	drivers/net/ethernet/freescale/fec_ptp.c

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:	drivers/video/fbdev/imxfb.c
F:	include/linux/platform_data/video-imxfb.h

FREESCALE IMX DDR PMU DRIVER
M:	Frank Li <Frank.li@nxp.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/admin-guide/perf/imx-ddr.rst
F:	Documentation/devicetree/bindings/perf/fsl-imx-ddr.yaml
F:	drivers/perf/fsl_imx8_ddr_perf.c

FREESCALE IMX I2C DRIVER
M:	Oleksij Rempel <o.rempel@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-imx.yaml
F:	drivers/i2c/busses/i2c-imx.c

FREESCALE IMX LPI2C DRIVER
M:	Dong Aisheng <aisheng.dong@nxp.com>
L:	linux-i2c@vger.kernel.org
L:	linux-imx@nxp.com
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-imx-lpi2c.yaml
F:	drivers/i2c/busses/i2c-imx-lpi2c.c

FREESCALE MPC I2C DRIVER
M:	Chris Packham <chris.packham@alliedtelesis.co.nz>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-mpc.yaml
F:	drivers/i2c/busses/i2c-mpc.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:	Documentation/devicetree/bindings/net/fsl-fman.txt
F:	drivers/net/ethernet/freescale/fman

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

FREESCALE QUAD SPI DRIVER
M:	Han Xu <han.xu@nxp.com>
L:	linux-spi@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/spi/fsl,spi-fsl-qspi.yaml
F:	drivers/spi/spi-fsl-qspi.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/

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@kernel.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 (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/misc/fsl,dpaa2-console.yaml
F:	Documentation/devicetree/bindings/soc/fsl/
F:	drivers/soc/fsl/
F:	include/linux/fsl/
F:	include/soc/fsl/

FREESCALE SOC FS_ENET DRIVER
M:	Pantelis Antoniou <pantelis.antoniou@gmail.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:	Shengjiu Wang <shengjiu.wang@gmail.com>
M:	Xiubo Li <Xiubo.Lee@gmail.com>
R:	Fabio Estevam <festevam@gmail.com>
R:	Nicolin Chen <nicoleotsuka@gmail.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*

FREESCALE USB PHY DRIVER
M:	Ran Wang <ran.wang_1@nxp.com>
L:	linux-usb@vger.kernel.org
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	drivers/usb/phy/phy-fsl-usb*

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

FREEZER
M:	"Rafael J. Wysocki" <rafael@kernel.org>
M:	Pavel Machek <pavel@ucw.cz>
L:	linux-pm@vger.kernel.org
S:	Supported
F:	Documentation/power/freezing-of-tasks.rst
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:	include/linux/frontswap.h
F:	mm/frontswap.c

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>
M:	Eric Biggers <ebiggers@kernel.org>
L:	linux-fscrypt@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-fscrypt/list/
T:	git git://git.kernel.org/pub/scm/fs/fscrypt/fscrypt.git
F:	Documentation/filesystems/fscrypt.rst
F:	fs/crypto/
F:	include/linux/fscrypt*.h
F:	include/uapi/linux/fscrypt.h

FSI SUBSYSTEM
M:	Jeremy Kerr <jk@ozlabs.org>
M:	Joel Stanley <joel@jms.id.au>
R:	Alistar Popple <alistair@popple.id.au>
R:	Eddie James <eajames@linux.ibm.com>
L:	linux-fsi@lists.ozlabs.org
S:	Supported
Q:	http://patchwork.ozlabs.org/project/linux-fsi/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/joel/fsi.git
F:	drivers/fsi/
F:	include/linux/fsi*.h
F:	include/trace/events/fsi*.h

FSI-ATTACHED I2C DRIVER
M:	Eddie James <eajames@linux.ibm.com>
L:	linux-i2c@vger.kernel.org
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-fsi.txt
F:	drivers/i2c/busses/i2c-fsi.c

FSI-ATTACHED SPI DRIVER
M:	Eddie James <eajames@linux.ibm.com>
L:	linux-spi@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/fsi/ibm,fsi2spi.yaml
F:	drivers/spi/spi-fsi.c

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

FSVERITY: READ-ONLY FILE-BASED AUTHENTICITY PROTECTION
M:	Eric Biggers <ebiggers@kernel.org>
M:	Theodore Y. Ts'o <tytso@mit.edu>
L:	linux-fscrypt@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-fscrypt/list/
T:	git git://git.kernel.org/pub/scm/fs/fscrypt/fscrypt.git fsverity
F:	Documentation/filesystems/fsverity.rst
F:	fs/verity/
F:	include/linux/fsverity.h
F:	include/uapi/linux/fsverity.h

FT260 FTDI USB-HID TO I2C BRIDGE DRIVER
M:	Michael Zaidman <michael.zaidman@gmail.com>
L:	linux-i2c@vger.kernel.org
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/hid-ft260.c

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

FUNGIBLE ETHERNET DRIVERS
M:	Dimitris Michailidis <dmichail@fungible.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/fungible/

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

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>
R:	Davidlohr Bueso <dave@stgolabs.net>
R:	André Almeida <andrealmeid@igalia.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git locking/core
F:	Documentation/locking/*futex*
F:	include/asm-generic/futex.h
F:	include/linux/futex.h
F:	include/uapi/linux/futex.h
F:	kernel/futex/*
F:	tools/perf/bench/futex*
F:	tools/testing/selftests/futex/

GATEWORKS SYSTEM CONTROLLER (GSC) DRIVER
M:	Tim Harvey <tharvey@gateworks.com>
M:	Robert Jones <rjones@gateworks.com>
S:	Maintained
F:	Documentation/devicetree/bindings/mfd/gateworks-gsc.yaml
F:	drivers/mfd/gateworks-gsc.c
F:	include/linux/mfd/gsc.h
F:	Documentation/hwmon/gsc-hwmon.rst
F:	drivers/hwmon/gsc-hwmon.c
F:	include/linux/platform_data/gsc_hwmon.h

GCC PLUGINS
M:	Kees Cook <keescook@chromium.org>
L:	linux-hardening@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
F:	Documentation/kbuild/gcc-plugins.rst
F:	scripts/Makefile.gcc-plugins
F:	scripts/gcc-plugins/

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

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

GEMINI CRYPTO DRIVER
M:	Corentin Labbe <clabbe@baylibre.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/gemini/

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

GENERIC ARCHITECTURE TOPOLOGY
M:	Sudeep Holla <sudeep.holla@arm.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/base/arch_topology.c
F:	include/linux/arch_topology.h

GENERIC ENTRY CODE
M:	Thomas Gleixner <tglx@linutronix.de>
M:	Peter Zijlstra <peterz@infradead.org>
M:	Andy Lutomirski <luto@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git core/entry
F:	include/linux/entry-common.h
F:	include/linux/entry-kvm.h
F:	kernel/entry/

GENERIC GPIO I2C DRIVER
M:	Wolfram Sang <wsa+renesas@sang-engineering.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:	Documentation/i2c/muxes/i2c-mux-gpio.rst
F:	drivers/i2c/muxes/i2c-mux-gpio.c
F:	include/linux/platform_data/i2c-mux-gpio.h

GENERIC HDLC (WAN) DRIVERS
M:	Krzysztof Halasa <khc@pm.waw.pl>
S:	Maintained
W:	http://www.kernel.org/pub/linux/utils/net/hdlc/
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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/arnd/asm-generic.git
F:	include/asm-generic/
F:	include/uapi/asm-generic/

GENERIC PHY FRAMEWORK
M:	Kishon Vijay Abraham I <kishon@ti.com>
M:	Vinod Koul <vkoul@kernel.org>
L:	linux-phy@lists.infradead.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-phy/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/phy/linux-phy.git
F:	Documentation/devicetree/bindings/phy/
F:	drivers/phy/
F:	include/dt-bindings/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" <rafael@kernel.org>
M:	Kevin Hilman <khilman@kernel.org>
M:	Ulf Hansson <ulf.hansson@linaro.org>
L:	linux-pm@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/power/power?domain*
F:	drivers/base/power/domain*.c
F:	include/linux/pm_domain.h

GENERIC RESISTIVE TOUCHSCREEN ADC DRIVER
M:	Eugen Hristev <eugen.hristev@microchip.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/input/touchscreen/resistive-adc-touch.c

GENERIC STRING LIBRARY
R:	Andy Shevchenko <andy@kernel.org>
S:	Maintained
F:	lib/string.c
F:	lib/string_helpers.c
F:	lib/test_string.c
F:	lib/test-string_helpers.c

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

GENERIC VDSO LIBRARY
M:	Andy Lutomirski <luto@kernel.org>
M:	Thomas Gleixner <tglx@linutronix.de>
M:	Vincenzo Frascino <vincenzo.frascino@arm.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/vdso
F:	include/asm-generic/vdso/vsyscall.h
F:	include/vdso/
F:	kernel/time/vsyscall.c
F:	lib/vdso/

GENWQE (IBM Generic Workqueue Card)
M:	Frank Haverkamp <haver@linux.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
S:	Supported
B:	https://bugzilla.kernel.org/enter_bug.cgi?product=File%20System&component=gfs2
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2.git
F:	Documentation/filesystems/gfs2*
F:	fs/gfs2/
F:	include/uapi/linux/gfs2_ondisk.h

GIGABYTE WMI DRIVER
M:	Thomas Weißschuh <thomas@weissschuh.net>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/gigabyte-wmi.c

GNSS SUBSYSTEM
M:	Johan Hovold <johan@kernel.org>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/johan/gnss.git
F:	Documentation/ABI/testing/sysfs-class-gnss
F:	Documentation/devicetree/bindings/gnss/
F:	drivers/gnss/
F:	include/linux/gnss.h

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

GOODIX TOUCHSCREEN
M:	Bastien Nocera <hadess@hadess.net>
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/input/touchscreen/goodix*

GOOGLE ETHERNET DRIVERS
M:	Jeroen de Borst <jeroendb@google.com>
R:	Catherine Sullivan <csully@google.com>
R:	David Awogbemila <awogbemila@google.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/device_drivers/ethernet/google/gve.rst
F:	drivers/net/ethernet/google

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:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/andy/linux-gpio-intel.git
F:	Documentation/firmware-guide/acpi/gpio-properties.rst
F:	drivers/gpio/gpiolib-acpi.c
F:	drivers/gpio/gpiolib-acpi.h

GPIO AGGREGATOR
M:	Geert Uytterhoeven <geert+renesas@glider.be>
L:	linux-gpio@vger.kernel.org
S:	Supported
F:	Documentation/admin-guide/gpio/gpio-aggregator.rst
F:	drivers/gpio/gpio-aggregator.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>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-mockup.c
F:	tools/testing/selftests/gpio/

GPIO REGMAP
R:	Michael Walle <michael@walle.cc>
S:	Maintained
F:	drivers/gpio/gpio-regmap.c
F:	include/linux/gpio/regmap.h

GPIO SUBSYSTEM
M:	Linus Walleij <linus.walleij@linaro.org>
M:	Bartosz Golaszewski <brgl@bgdev.pl>
L:	linux-gpio@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/brgl/linux.git
F:	Documentation/ABI/obsolete/sysfs-gpio
F:	Documentation/ABI/testing/gpio-cdev
F:	Documentation/admin-guide/gpio/
F:	Documentation/devicetree/bindings/gpio/
F:	Documentation/driver-api/gpio/
F:	drivers/gpio/
F:	include/asm-generic/gpio.h
F:	include/dt-bindings/gpio/
F:	include/linux/gpio.h
F:	include/linux/gpio/
F:	include/linux/of_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:	include/net/gre.h
F:	net/ipv4/gre_demux.c
F:	net/ipv4/gre_offload.c

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-management.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 DRIVER
M:	Bryan O'Donoghue <pure.logic@nexus-software.ie>
S:	Maintained
F:	drivers/staging/greybus/loopback.c

GREYBUS PLATFORM DRIVERS
M:	Vaibhav Hiremath <hvaibhav.linux@gmail.com>
S:	Maintained
F:	drivers/staging/greybus/arche-apb-ctrl.c
F:	drivers/staging/greybus/arche-platform.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/gpio.c
F:	drivers/staging/greybus/light.c
F:	drivers/staging/greybus/power_supply.c
F:	drivers/staging/greybus/sdio.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>
L:	greybus-dev@lists.linaro.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/greybus/
F:	drivers/staging/greybus/
F:	include/linux/greybus.h
F:	include/linux/greybus/

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

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

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

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

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

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

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

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

GSPCA USB WEBCAM DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
T:	git git://linuxtv.org/media_tree.git
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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pablo/gtp.git
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.*

HABANALABS PCI DRIVER
M:	Oded Gabbay <ogabbay@kernel.org>
S:	Supported
T:	git https://git.kernel.org/pub/scm/linux/kernel/git/ogabbay/linux.git
F:	Documentation/ABI/testing/debugfs-driver-habanalabs
F:	Documentation/ABI/testing/sysfs-driver-habanalabs
F:	drivers/misc/habanalabs/
F:	include/uapi/misc/habanalabs.h

HACKRF MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/usb/hackrf/

HANTRO VPU CODEC DRIVER
M:	Ezequiel Garcia <ezequiel@vanguardiasur.com.ar>
M:	Philipp Zabel <p.zabel@pengutronix.de>
L:	linux-media@vger.kernel.org
L:	linux-rockchip@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/nxp,imx8mq-vpu.yaml
F:	Documentation/devicetree/bindings/media/rockchip,rk3568-vepu.yaml
F:	Documentation/devicetree/bindings/media/rockchip-vpu.yaml
F:	drivers/staging/media/hantro/

HARD DRIVE ACTIVE PROTECTION SYSTEM (HDAPS) DRIVER
M:	Frank Seidel <frank@f-seidel.de>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
W:	http://www.kernel.org/pub/linux/kernel/people/fseidel/hdaps/
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
S:	Maintained
W:	http://hwmon.wiki.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging.git
F:	Documentation/ABI/testing/sysfs-class-hwmon
F:	Documentation/devicetree/bindings/hwmon/
F:	Documentation/hwmon/
F:	drivers/hwmon/
F:	include/linux/hwmon*.h
F:	include/trace/events/hwmon*.h
K:	(devm_)?hwmon_device_(un)?register(|_with_groups|_with_info)

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

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

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

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
S:	Odd Fixes
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/usb/hdpvr/

HEWLETT PACKARD ENTERPRISE ILO CHIF DRIVER
M:	Matt Hsiao <matt.hsiao@hpe.com>
S:	Supported
F:	drivers/misc/hpilo.[ch]

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

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

HFI1 DRIVER
M:	Dennis Dalessandro <dennis.dalessandro@cornelisnetworks.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.rst
F:	fs/hfs/

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

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

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

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

HID LOGITECH DRIVERS
R:	Filipe Laíns <lains@riseup.net>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/hid-logitech-*

HID PLAYSTATION DRIVER
M:	Roderick Colenbrander <roderick.colenbrander@sony.com>
L:	linux-input@vger.kernel.org
S:	Supported
F:	drivers/hid/hid-playstation.c

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

HID WACOM DRIVER
M:	Ping Cheng <ping.cheng@wacom.com>
M:	Jason Gerecke  <jason.gerecke@wacom.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/wacom.h
F:	drivers/hid/wacom_*

HIGH-RESOLUTION TIMERS, CLOCKEVENTS
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 timers/core
F:	Documentation/timers/
F:	include/linux/clockchips.h
F:	include/linux/hrtimer.h
F:	kernel/time/clockevents.c
F:	kernel/time/hrtimer.c
F:	kernel/time/timer_*.c

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

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

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

HIRSCHMANN HELLCREEK ETHERNET SWITCH DRIVER
M:	Kurt Kanzenbach <kurt@linutronix.de>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/dsa/hirschmann,hellcreek.yaml
F:	drivers/net/dsa/hirschmann/*
F:	include/linux/platform_data/hirschmann-hellcreek.h
F:	net/dsa/tag_hellcreek.c

HISILICON DMA DRIVER
M:	Zhou Wang <wangzhou1@hisilicon.com>
L:	dmaengine@vger.kernel.org
S:	Maintained
F:	drivers/dma/hisi_dma.c

HISILICON GPIO DRIVER
M:	Luo Jiaxing <luojiaxing@huawei.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-hisi.c

HISILICON HIGH PERFORMANCE RSA ENGINE DRIVER (HPRE)
M:	Longfang Liu <liulongfang@huawei.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/debugfs-hisi-hpre
F:	drivers/crypto/hisilicon/hpre/hpre.h
F:	drivers/crypto/hisilicon/hpre/hpre_crypto.c
F:	drivers/crypto/hisilicon/hpre/hpre_main.c

HISILICON I2C CONTROLLER DRIVER
M:	Yicong Yang <yangyicong@hisilicon.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
W:	https://www.hisilicon.com
F:	drivers/i2c/busses/i2c-hisi.c

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

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
S:	Maintained
W:	http://www.hisilicon.com
F:	drivers/net/ethernet/hisilicon/hns3/

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

HIKEY960 ONBOARD USB GPIO HUB DRIVER
M:	John Stultz <jstultz@google.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/misc/hisi_hikey_usb.c

HISILICON PMU DRIVER
M:	Shaokun Zhang <zhangshaokun@hisilicon.com>
M:	Qi Liu <liuqi115@huawei.com>
S:	Supported
W:	http://www.hisilicon.com
F:	Documentation/admin-guide/perf/hisi-pcie-pmu.rst
F:	Documentation/admin-guide/perf/hisi-pmu.rst
F:	drivers/perf/hisilicon

HISILICON HNS3 PMU DRIVER
M:	Guangbin Huang <huangguangbin2@huawei.com>
S:	Supported
F:	Documentation/admin-guide/perf/hns3-pmu.rst
F:	drivers/perf/hisilicon/hns3_pmu.c

HISILICON QM DRIVER
M:	Weili Qian <qianweili@huawei.com>
M:	Zhou Wang <wangzhou1@hisilicon.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/hisilicon/Kconfig
F:	drivers/crypto/hisilicon/Makefile
F:	drivers/crypto/hisilicon/qm.c
F:	drivers/crypto/hisilicon/sgl.c
F:	include/linux/hisi_acc_qm.h

HISILICON ZIP Controller DRIVER
M:	Yang Shen <shenyang39@huawei.com>
M:	Zhou Wang <wangzhou1@hisilicon.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/debugfs-hisi-zip
F:	drivers/crypto/hisilicon/zip/

HISILICON ROCE DRIVER
M:	Wenpeng Liang <liangwenpeng@huawei.com>
M:	Weihang Li <liweihang@huawei.com>
L:	linux-rdma@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/infiniband/hisilicon-hns-roce.txt
F:	drivers/infiniband/hw/hns/

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

HISILICON SECURITY ENGINE V2 DRIVER (SEC2)
M:	Kai Ye <yekai13@huawei.com>
M:	Longfang Liu <liulongfang@huawei.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/debugfs-hisi-sec
F:	drivers/crypto/hisilicon/sec2/sec.h
F:	drivers/crypto/hisilicon/sec2/sec_crypto.c
F:	drivers/crypto/hisilicon/sec2/sec_crypto.h
F:	drivers/crypto/hisilicon/sec2/sec_main.c

HISILICON SPI Controller DRIVER FOR KUNPENG SOCS
M:	Jay Fang <f.fangjian@huawei.com>
L:	linux-spi@vger.kernel.org
S:	Maintained
W:	http://www.hisilicon.com
F:	drivers/spi/spi-hisi-kunpeng.c

HISILICON SPMI CONTROLLER DRIVER FOR HIKEY 970
M:	Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/spmi/hisilicon,hisi-spmi-controller.yaml
F:	drivers/spmi/hisi-spmi-controller.c

HISILICON SPMI PMIC DRIVER FOR HIKEY 6421v600
M:	Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/mfd/hisilicon,hi6421-spmi-pmic.yaml
F:	drivers/mfd/hi6421-spmi-pmic.c

HISILICON TRUE RANDOM NUMBER GENERATOR V2 SUPPORT
M:	Weili Qian <qianweili@huawei.com>
S:	Maintained
F:	drivers/crypto/hisilicon/trng/trng.c

HISILICON V3XX SPI NOR FLASH Controller Driver
M:	John Garry <john.garry@huawei.com>
S:	Maintained
W:	http://www.hisilicon.com
F:	drivers/spi/spi-hisi-sfc-v3xx.c

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

HOST AP DRIVER
M:	Jouni Malinen <j@w1.fi>
L:	linux-wireless@vger.kernel.org
S:	Obsolete
W:	http://w1.fi/hostap-driver.html
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

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

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

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

HSI SUBSYSTEM
M:	Sebastian Reichel <sre@kernel.org>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-hsi.git
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
L:	netdev@vger.kernel.org
S:	Orphan
F:	net/hsr/

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

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

HTE SUBSYSTEM
M:	Dipen Patel <dipenp@nvidia.com>
S:	Maintained
F:	Documentation/devicetree/bindings/timestamp/
F:	Documentation/driver-api/hte/
F:	drivers/hte/
F:	include/linux/hte.h

HTS221 TEMPERATURE-HUMIDITY IIO DRIVER
M:	Lorenzo Bianconi <lorenzo@kernel.org>
L:	linux-iio@vger.kernel.org
S:	Maintained
W:	http://www.st.com/
F:	Documentation/devicetree/bindings/iio/humidity/st,hts221.yaml
F:	drivers/iio/humidity/hts221*

HUAWEI ETHERNET DRIVER
L:	netdev@vger.kernel.org
S:	Orphan
F:	Documentation/networking/device_drivers/ethernet/huawei/hinic.rst
F:	drivers/net/ethernet/huawei/hinic/

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

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

HWPOISON MEMORY FAILURE HANDLING
M:	Naoya Horiguchi <naoya.horiguchi@nec.com>
R:	Miaohe Lin <linmiaohe@huawei.com>
L:	linux-mm@kvack.org
S:	Maintained
F:	mm/hwpoison-inject.c
F:	mm/memory-failure.c

HYCON HY46XX TOUCHSCREEN SUPPORT
M:	Giulio Benetti <giulio.benetti@benettiengineering.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/input/touchscreen/hycon,hy46xx.yaml
F:	drivers/input/touchscreen/hycon-hy46xx.c

HYGON PROCESSOR SUPPORT
M:	Pu Wen <puwen@hygon.cn>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	arch/x86/kernel/cpu/hygon.c

HYNIX HI556 SENSOR DRIVER
M:	Shawn Tu <shawnx.tu@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/hi556.c

HYNIX HI846 SENSOR DRIVER
M:	Martin Kepplinger <martin.kepplinger@puri.sm>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/hi846.c

HYNIX HI847 SENSOR DRIVER
M:	Shawn Tu <shawnx.tu@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/hi847.c

Hyper-V/Azure CORE AND DRIVERS
M:	"K. Y. Srinivasan" <kys@microsoft.com>
M:	Haiyang Zhang <haiyangz@microsoft.com>
M:	Stephen Hemminger <sthemmin@microsoft.com>
M:	Wei Liu <wei.liu@kernel.org>
M:	Dexuan Cui <decui@microsoft.com>
L:	linux-hyperv@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/hyperv/linux.git
F:	Documentation/ABI/stable/sysfs-bus-vmbus
F:	Documentation/ABI/testing/debugfs-hyperv
F:	Documentation/virt/hyperv
F:	Documentation/networking/device_drivers/ethernet/microsoft/netvsc.rst
F:	arch/arm64/hyperv
F:	arch/arm64/include/asm/hyperv-tlfs.h
F:	arch/arm64/include/asm/mshyperv.h
F:	arch/x86/hyperv
F:	arch/x86/include/asm/hyperv-tlfs.h
F:	arch/x86/include/asm/mshyperv.h
F:	arch/x86/include/asm/trace/hyperv.h
F:	arch/x86/kernel/cpu/mshyperv.c
F:	drivers/clocksource/hyperv_timer.c
F:	drivers/hid/hid-hyperv.c
F:	drivers/hv/
F:	drivers/input/serio/hyperv-keyboard.c
F:	drivers/iommu/hyperv-iommu.c
F:	drivers/net/ethernet/microsoft/
F:	drivers/net/hyperv/
F:	drivers/pci/controller/pci-hyperv-intf.c
F:	drivers/pci/controller/pci-hyperv.c
F:	drivers/scsi/storvsc_drv.c
F:	drivers/uio/uio_hv_generic.c
F:	drivers/video/fbdev/hyperv_fb.c
F:	include/asm-generic/hyperv-tlfs.h
F:	include/asm-generic/mshyperv.h
F:	include/clocksource/hyperv_timer.h
F:	include/linux/hyperv.h
F:	include/uapi/linux/hyperv.h
F:	net/vmw_vsock/hyperv_transport.c
F:	tools/hv/

HYPERBUS SUPPORT
M:	Vignesh Raghavendra <vigneshr@ti.com>
L:	linux-mtd@lists.infradead.org
S:	Supported
Q:	http://patchwork.ozlabs.org/project/linux-mtd/list/
C:	irc://irc.oftc.net/mtd
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mtd/linux.git cfi/next
F:	Documentation/devicetree/bindings/mtd/ti,am654-hbmc.yaml
F:	drivers/mtd/hyperbus/
F:	include/linux/mtd/hyperbus.h

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 CONTROLLER DRIVER FOR NVIDIA GPU
M:	Ajay Gupta <ajayg@nvidia.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/i2c/busses/i2c-nvidia-gpu.rst
F:	drivers/i2c/busses/i2c-nvidia-gpu.c

I2C MUXES
M:	Peter Rosin <peda@axentia.se>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-arb*
F:	Documentation/devicetree/bindings/i2c/i2c-gate*
F:	Documentation/devicetree/bindings/i2c/i2c-mux*
F:	Documentation/i2c/i2c-topology.rst
F:	Documentation/i2c/muxes/
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:	Documentation/devicetree/bindings/i2c/marvell,mv64xxx-i2c.yaml
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.rst
F:	drivers/i2c/busses/i2c-parport.c

I2C SUBSYSTEM
M:	Wolfram Sang <wsa@kernel.org>
L:	linux-i2c@vger.kernel.org
S:	Maintained
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
F:	Documentation/devicetree/bindings/i2c/i2c.txt
F:	Documentation/i2c/
F:	drivers/i2c/*
F:	include/dt-bindings/i2c/i2c.h
F:	include/linux/i2c-dev.h
F:	include/linux/i2c-smbus.h
F:	include/linux/i2c.h
F:	include/uapi/linux/i2c-*.h
F:	include/uapi/linux/i2c.h

I2C SUBSYSTEM HOST DRIVERS
L:	linux-i2c@vger.kernel.org
S:	Odd Fixes
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
F:	Documentation/devicetree/bindings/i2c/
F:	drivers/i2c/algos/
F:	drivers/i2c/busses/
F:	include/dt-bindings/i2c/

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.rst
F:	drivers/i2c/busses/i2c-taos-evm.c

I2C-TINY-USB DRIVER
M:	Till Harbaum <till@harbaum.org>
L:	linux-i2c@vger.kernel.org
S:	Maintained
W:	http://www.harbaum.org/till/i2c_tiny_usb
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.rst
F:	Documentation/i2c/busses/i2c-ali1563.rst
F:	Documentation/i2c/busses/i2c-ali15x3.rst
F:	Documentation/i2c/busses/i2c-amd756.rst
F:	Documentation/i2c/busses/i2c-amd8111.rst
F:	Documentation/i2c/busses/i2c-i801.rst
F:	Documentation/i2c/busses/i2c-nforce2.rst
F:	Documentation/i2c/busses/i2c-piix4.rst
F:	Documentation/i2c/busses/i2c-sis5595.rst
F:	Documentation/i2c/busses/i2c-sis630.rst
F:	Documentation/i2c/busses/i2c-sis96x.rst
F:	Documentation/i2c/busses/i2c-via.rst
F:	Documentation/i2c/busses/i2c-viapro.rst
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-s4882.c
F:	drivers/i2c/busses/i2c-amd756.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-s4985.c
F:	drivers/i2c/busses/i2c-nforce2.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:	Documentation/i2c/busses/i2c-ismt.rst
F:	drivers/i2c/busses/i2c-ismt.c

I2C/SMBUS STUB DRIVER
M:	Jean Delvare <jdelvare@suse.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/i2c-stub.c

I3C DRIVER FOR CADENCE I3C MASTER IP
M:	Przemysław Gaj <pgaj@cadence.com>
S:	Maintained
F:	Documentation/devicetree/bindings/i3c/cdns,i3c-master.yaml
F:	drivers/i3c/master/i3c-master-cdns.c

I3C DRIVER FOR SYNOPSYS DESIGNWARE
M:	Vitor Soares <vitor.soares@synopsys.com>
S:	Maintained
F:	Documentation/devicetree/bindings/i3c/snps,dw-i3c-master.yaml
F:	drivers/i3c/master/dw*

I3C SUBSYSTEM
M:	Alexandre Belloni <alexandre.belloni@bootlin.com>
L:	linux-i3c@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
C:	irc://chat.freenode.net/linux-i3c
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/i3c/linux.git
F:	Documentation/ABI/testing/sysfs-bus-i3c
F:	Documentation/devicetree/bindings/i3c/
F:	Documentation/driver-api/i3c
F:	drivers/i3c/
F:	include/linux/i3c/

IA64 (Itanium) PLATFORM
L:	linux-ia64@vger.kernel.org
S:	Orphan
F:	Documentation/ia64/
F:	arch/ia64/

IBM Power 842 compression accelerator
M:	Haren Myneni <haren@us.ibm.com>
S:	Supported
F:	crypto/842.c
F:	drivers/crypto/nx/Kconfig
F:	drivers/crypto/nx/Makefile
F:	drivers/crypto/nx/nx-842*
F:	include/linux/sw842.h
F:	lib/842/

IBM Power in-Nest Crypto Acceleration
M:	Breno Leitão <leitao@debian.org>
M:	Nayna Jain <nayna@linux.ibm.com>
M:	Paulo Flabiano Smorigo <pfsmorigo@gmail.com>
L:	linux-crypto@vger.kernel.org
S:	Supported
F:	drivers/crypto/nx/Kconfig
F:	drivers/crypto/nx/Makefile
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.c

IBM Power IO DLPAR Driver for RPA-compliant PPC64 platform
M:	Tyrel Datwyler <tyreld@linux.ibm.com>
L:	linux-pci@vger.kernel.org
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
F:	drivers/pci/hotplug/rpadlpar*

IBM Power Linux RAID adapter
M:	Brian King <brking@us.ibm.com>
S:	Supported
F:	drivers/scsi/ipr.*

IBM Power PCI Hotplug Driver for RPA-compliant PPC64 platform
M:	Tyrel Datwyler <tyreld@linux.ibm.com>
L:	linux-pci@vger.kernel.org
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
F:	drivers/pci/hotplug/rpaphp*

IBM Power SRIOV Virtual NIC Device Driver
M:	Dany Madden <drt@linux.ibm.com>
R:	Thomas Falcon <tlfalcon@linux.ibm.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/ibm/ibmvnic.*

IBM Power Virtual Accelerator Switchboard
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
F:	arch/powerpc/include/asm/vas.h
F:	arch/powerpc/platforms/powernv/copy-paste.h
F:	arch/powerpc/platforms/powernv/vas*

IBM Power Virtual Ethernet Device Driver
M:	Cristobal Forno <cforno12@linux.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.ibm.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/ibmvscsi/ibmvfc*

IBM Power Virtual Management Channel Driver
M:	Brad Warrum <bwarrum@linux.ibm.com>
M:	Ritu Agarwal <rituagar@linux.ibm.com>
S:	Supported
F:	drivers/misc/ibmvmc.*

IBM Power Virtual SCSI Device Drivers
M:	Tyrel Datwyler <tyreld@linux.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:	Michael Cyr <mikecyr@linux.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:	Breno Leitão <leitao@debian.org>
M:	Nayna Jain <nayna@linux.ibm.com>
M:	Paulo Flabiano Smorigo <pfsmorigo@gmail.com>
L:	linux-crypto@vger.kernel.org
S:	Supported
F:	drivers/crypto/vmx/Kconfig
F:	drivers/crypto/vmx/Makefile
F:	drivers/crypto/vmx/aes*
F:	drivers/crypto/vmx/ghash*
F:	drivers/crypto/vmx/ppc-xlate.pl
F:	drivers/crypto/vmx/vmx.c

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/gpio/gpio-ich.c
F:	drivers/mfd/lpc_ich.c

ICY I2C DRIVER
M:	Max Staudt <max@enpas.org>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/busses/i2c-icy.c

IDEAPAD LAPTOP EXTRAS DRIVER
M:	Ike Panhc <ike.pan@canonical.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
W:	http://launchpad.net/ideapad-laptop
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
S:	Maintained
W:	https://github.com/o2genum/ideapad-slidebar
F:	drivers/input/misc/ideapad_slidebar.c

IDMAPPED MOUNTS
M:	Christian Brauner <brauner@kernel.org>
M:	Seth Forshee <sforshee@kernel.org>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/brauner/linux.git
F:	Documentation/filesystems/idmappings.rst
F:	tools/testing/selftests/mount_setattr/
F:	include/linux/mnt_idmapping.h

IDT VersaClock 5 CLOCK DRIVER
M:	Luca Ceresoli <luca@lucaceresoli.net>
S:	Maintained
F:	Documentation/devicetree/bindings/clock/idt,versaclock5.yaml
F:	drivers/clk/clk-versaclock5.c

IEEE 802.15.4 SUBSYSTEM
M:	Alexander Aring <alex.aring@gmail.com>
M:	Stefan Schmidt <stefan@datenfreihafen.org>
L:	linux-wpan@vger.kernel.org
S:	Maintained
W:	https://linux-wpan.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
F:	Documentation/networking/ieee802154.rst
F:	drivers/net/ieee802154/
F:	include/linux/ieee802154.h
F:	include/linux/nl802154.h
F:	include/net/af_ieee802154.h
F:	include/net/cfg802154.h
F:	include/net/ieee802154_netdev.h
F:	include/net/mac802154.h
F:	include/net/nl802154.h
F:	net/ieee802154/
F:	net/mac802154/

IFE PROTOCOL
M:	Yotam Gigi <yotam.gi@gmail.com>
M:	Jamal Hadi Salim <jhs@mojatatu.com>
F:	include/net/ife.h
F:	include/uapi/linux/ife.h
F:	net/ife

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.yaml
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.yaml
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/io-channel-mux.yaml
F:	drivers/iio/multiplexer/iio-mux.c

IIO SCMI BASED DRIVER
M:	Jyoti Bhayana <jbhayana@google.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	drivers/iio/common/scmi_sensors/scmi_iio.c

IIO SUBSYSTEM AND DRIVERS
M:	Jonathan Cameron <jic23@kernel.org>
R:	Lars-Peter Clausen <lars@metafoo.de>
L:	linux-iio@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio.git
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/dt-bindings/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.yaml
F:	Documentation/devicetree/bindings/iio/afe/current-sense-shunt.yaml
F:	Documentation/devicetree/bindings/iio/afe/voltage-divider.yaml
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

IMAGIS TOUCHSCREEN DRIVER
M:	Markuss Broks <markuss.broks@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/input/touchscreen/imagis,ist3038c.yaml
F:	drivers/input/touchscreen/imagis.c

IMGTEC ASCII LCD DRIVER
M:	Paul Burton <paulburton@kernel.org>
S:	Maintained
F:	Documentation/devicetree/bindings/auxdisplay/img,ascii-lcd.yaml
F:	drivers/auxdisplay/img-ascii-lcd.c

IMGTEC IR DECODER DRIVER
S:	Orphan
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.c
F:	drivers/media/rc/imon_raw.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/devicetree/bindings/hwmon/ti,ina2xx.yaml
F:	Documentation/hwmon/ina209.rst
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.rst
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
S:	Maintained
W:	http://industrypack.sourceforge.net
F:	drivers/ipack/

INFINEON DPS310 Driver
M:	Eddie James <eajames@linux.ibm.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	drivers/iio/pressure/dps310.c

INFINIBAND SUBSYSTEM
M:	Jason Gunthorpe <jgg@nvidia.com>
M:	Leon Romanovsky <leonro@nvidia.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
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
F:	Documentation/devicetree/bindings/infiniband/
F:	Documentation/infiniband/
F:	drivers/infiniband/
F:	include/rdma/
F:	include/trace/events/ib_mad.h
F:	include/trace/events/ib_umad.h
F:	include/uapi/linux/if_infiniband.h
F:	include/uapi/rdma/
F:	samples/bpf/ibumad_kern.c
F:	samples/bpf/ibumad_user.c

INGENIC JZ4780 NAND DRIVER
M:	Harvey Hunt <harveyhuntnexus@gmail.com>
L:	linux-mtd@lists.infradead.org
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	drivers/mtd/nand/raw/ingenic/

INGENIC JZ47xx SoCs
M:	Paul Cercueil <paul@crapouillou.net>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	arch/mips/boot/dts/ingenic/
F:	arch/mips/generic/board-ingenic.c
F:	arch/mips/include/asm/mach-ingenic/
F:	arch/mips/ingenic/Kconfig
F:	drivers/clk/ingenic/
F:	drivers/dma/dma-jz4780.c
F:	drivers/gpu/drm/ingenic/
F:	drivers/i2c/busses/i2c-jz4780.c
F:	drivers/iio/adc/ingenic-adc.c
F:	drivers/irqchip/irq-ingenic.c
F:	drivers/memory/jz4780-nemc.c
F:	drivers/mmc/host/jz4740_mmc.c
F:	drivers/mtd/nand/raw/ingenic/
F:	drivers/pinctrl/pinctrl-ingenic.c
F:	drivers/power/supply/ingenic-battery.c
F:	drivers/pwm/pwm-jz4740.c
F:	drivers/remoteproc/ingenic_rproc.c
F:	drivers/rtc/rtc-jz4740.c
F:	drivers/tty/serial/8250/8250_ingenic.c
F:	drivers/usb/musb/jz4740.c
F:	drivers/watchdog/jz4740_wdt.c
F:	include/dt-bindings/iio/adc/ingenic,adc.h
F:	include/linux/mfd/ingenic-tcu.h
F:	sound/soc/codecs/jz47*
F:	sound/soc/jz4740/

INJOINIC IP5xxx POWER BANK IC DRIVER
M:	Samuel Holland <samuel@sholland.org>
S:	Maintained
F:	drivers/power/supply/ip5xxx_power.c

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.rst
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
S:	Maintained
Q:	http://patchwork.kernel.org/project/linux-input/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git
F:	Documentation/devicetree/bindings/input/
F:	Documentation/devicetree/bindings/serio/
F:	Documentation/input/
F:	drivers/input/
F:	include/linux/input.h
F:	include/linux/input/
F:	include/uapi/linux/input-event-codes.h
F:	include/uapi/linux/input.h

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 <atenart@kernel.org>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/inside-secure/

INTEGRITY MEASUREMENT ARCHITECTURE (IMA)
M:	Mimi Zohar <zohar@linux.ibm.com>
M:	Dmitry Kasatkin <dmitry.kasatkin@gmail.com>
L:	linux-integrity@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/zohar/linux-integrity.git
F:	security/integrity/ima/
F:	security/integrity/

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 8255 GPIO DRIVER
M:	William Breathitt Gray <william.gray@linaro.org>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-i8255.c
F:	drivers/gpio/gpio-i8255.h

INTEL ASoC DRIVERS
M:	Cezary Rojewski <cezary.rojewski@intel.com>
M:	Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
M:	Liam Girdwood <liam.r.girdwood@linux.intel.com>
M:	Peter Ujfalusi <peter.ujfalusi@linux.intel.com>
M:	Bard Liao <yung-chuan.liao@linux.intel.com>
M:	Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
M:	Kai Vehmanen <kai.vehmanen@linux.intel.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
F:	sound/soc/intel/

INTEL ATOMISP2 DUMMY / POWER-MANAGEMENT DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/intel/atomisp2/pm.c

INTEL ATOMISP2 LED DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/intel/atomisp2/led.c

INTEL BIOS SAR INT1092 DRIVER
M:	Shravan Sudhakar <s.shravan@intel.com>
M:	Intel Corporation <linuxwwan@intel.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/intel/int1092/

INTEL BROXTON PMC DRIVER
M:	Mika Westerberg <mika.westerberg@linux.intel.com>
M:	Zha Qipeng <qipeng.zha@intel.com>
S:	Maintained
F:	drivers/mfd/intel_pmc_bxt.c
F:	include/linux/mfd/intel_pmc_bxt.h

INTEL C600 SERIES SAS CONTROLLER DRIVER
M:	Artur Paszkiewicz <artur.paszkiewicz@intel.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
T:	git git://git.code.sf.net/p/intel-sas/isci
F:	drivers/scsi/isci/

INTEL CPU family model numbers
M:	Tony Luck <tony.luck@intel.com>
M:	x86@kernel.org
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	arch/x86/include/asm/intel-family.h

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>
M:	Tvrtko Ursulin <tvrtko.ursulin@linux.intel.com>
L:	intel-gfx@lists.freedesktop.org
S:	Supported
W:	https://01.org/linuxgraphics/
Q:	http://patchwork.freedesktop.org/project/intel-gfx/
B:	https://gitlab.freedesktop.org/drm/intel/-/wikis/How-to-file-i915-bugs
C:	irc://irc.oftc.net/intel-gfx
T:	git git://anongit.freedesktop.org/drm-intel
F:	Documentation/gpu/i915.rst
F:	drivers/gpu/drm/i915/
F:	include/drm/i915*
F:	include/uapi/drm/i915_drm.h

INTEL ETHERNET DRIVERS
M:	Jesse Brandeburg <jesse.brandeburg@intel.com>
M:	Tony Nguyen <anthony.l.nguyen@intel.com>
L:	intel-wired-lan@lists.osuosl.org (moderated for non-subscribers)
S:	Supported
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/tnguy/net-queue.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tnguy/next-queue.git
F:	Documentation/networking/device_drivers/ethernet/intel/
F:	drivers/net/ethernet/intel/
F:	drivers/net/ethernet/intel/*/
F:	include/linux/avf/virtchnl.h
F:	include/linux/net/intel/iidc.h

INTEL ETHERNET PROTOCOL DRIVER FOR RDMA
M:	Mustafa Ismail <mustafa.ismail@intel.com>
M:	Shiraz Saleem <shiraz.saleem@intel.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
F:	drivers/infiniband/hw/irdma/
F:	include/uapi/rdma/irdma-abi.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.rst
F:	drivers/video/fbdev/intelfb/

INTEL GPIO DRIVERS
M:	Andy Shevchenko <andy@kernel.org>
L:	linux-gpio@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/andy/linux-gpio-intel.git
F:	drivers/gpio/gpio-ich.c
F:	drivers/gpio/gpio-merrifield.c
F:	drivers/gpio/gpio-ml-ioh.c
F:	drivers/gpio/gpio-pch.c
F:	drivers/gpio/gpio-sch.c
F:	drivers/gpio/gpio-sodaville.c

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
S:	Supported
W:	https://01.org/igvt-g
T:	git https://github.com/intel/gvt-linux.git
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
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-dmaengine/list/
F:	drivers/dma/ioat*

INTEL IDXD DRIVER
M:	Fenghua Yu <fenghua.yu@intel.com>
M:	Dave Jiang <dave.jiang@intel.com>
L:	dmaengine@vger.kernel.org
S:	Supported
F:	drivers/dma/idxd/*
F:	include/uapi/linux/idxd.h

INTEL IDLE DRIVER
M:	Jacob Pan <jacob.jun.pan@linux.intel.com>
M:	Len Brown <lenb@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Supported
B:	https://bugzilla.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux.git
F:	drivers/idle/intel_idle.c

INTEL IN FIELD SCAN (IFS) DEVICE
M:	Jithu Joseph <jithu.joseph@intel.com>
R:	Ashok Raj <ashok.raj@intel.com>
R:	Tony Luck <tony.luck@intel.com>
S:	Maintained
F:	drivers/platform/x86/intel/ifs
F:	include/trace/events/intel_ifs.h

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>
M:	Lu Baolu <baolu.lu@linux.intel.com>
L:	iommu@lists.linux.dev
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git
F:	drivers/iommu/intel/
F:	include/linux/intel-iommu.h
F:	include/linux/intel-svm.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>
M:	Bingbu Cao <bingbu.cao@intel.com>
M:	Dan Scally <djrscally@gmail.com>
R:	Tianshu Qiu <tian.shu.qiu@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/userspace-api/media/v4l/pixfmt-srggb10-ipu3.rst
F:	drivers/media/pci/intel/ipu3/

INTEL IPU3 CSI-2 IMGU DRIVER
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
R:	Bingbu Cao <bingbu.cao@intel.com>
R:	Tianshu Qiu <tian.shu.qiu@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/admin-guide/media/ipu3.rst
F:	Documentation/admin-guide/media/ipu3_rcb.svg
F:	Documentation/userspace-api/media/v4l/pixfmt-meta-intel-ipu3.rst
F:	drivers/staging/media/ipu3/

INTEL IXP4XX CRYPTO SUPPORT
M:	Corentin Labbe <clabbe@baylibre.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/ixp4xx_crypto.c

INTEL ISHTP ECLITE DRIVER
M:	Sumesh K Naduvalath <sumesh.k.naduvalath@intel.com>
L:	platform-driver-x86@vger.kernel.org
S:	Supported
F:	drivers/platform/x86/intel/ishtp_eclite.c

INTEL IXP4XX QMGR, NPE, ETHERNET and HSS SUPPORT
M:	Krzysztof Halasa <khalasa@piap.pl>
S:	Maintained
F:	drivers/net/ethernet/xscale/ixp4xx_eth.c
F:	drivers/net/wan/ixp4xx_hss.c
F:	drivers/soc/ixp4xx/ixp4xx-npe.c
F:	drivers/soc/ixp4xx/ixp4xx-qmgr.c
F:	include/linux/soc/ixp4xx/npe.h
F:	include/linux/soc/ixp4xx/qmgr.h

INTEL IXP4XX RANDOM NUMBER GENERATOR SUPPORT
M:	Deepak Saxena <dsaxena@plexity.net>
S:	Maintained
F:	Documentation/devicetree/bindings/rng/intel,ixp46x-rng.yaml
F:	drivers/char/hw_random/ixp4xx-rng.c

INTEL KEEM BAY DRM DRIVER
M:	Anitha Chrisanthus <anitha.chrisanthus@intel.com>
M:	Edmund Dea <edmund.j.dea@intel.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/intel,keembay-display.yaml
F:	drivers/gpu/drm/kmb/

INTEL KEEM BAY OCS AES/SM4 CRYPTO DRIVER
M:	Daniele Alessandrelli <daniele.alessandrelli@intel.com>
S:	Maintained
F:	Documentation/devicetree/bindings/crypto/intel,keembay-ocs-aes.yaml
F:	drivers/crypto/keembay/Kconfig
F:	drivers/crypto/keembay/Makefile
F:	drivers/crypto/keembay/keembay-ocs-aes-core.c
F:	drivers/crypto/keembay/ocs-aes.c
F:	drivers/crypto/keembay/ocs-aes.h

INTEL KEEM BAY OCS ECC CRYPTO DRIVER
M:	Daniele Alessandrelli <daniele.alessandrelli@intel.com>
M:	Prabhjot Khurana <prabhjot.khurana@intel.com>
M:	Mark Gross <mgross@linux.intel.com>
S:	Maintained
F:	Documentation/devicetree/bindings/crypto/intel,keembay-ocs-ecc.yaml
F:	drivers/crypto/keembay/Kconfig
F:	drivers/crypto/keembay/Makefile
F:	drivers/crypto/keembay/keembay-ocs-ecc.c

INTEL KEEM BAY OCS HCU CRYPTO DRIVER
M:	Daniele Alessandrelli <daniele.alessandrelli@intel.com>
M:	Declan Murphy <declan.murphy@intel.com>
S:	Maintained
F:	Documentation/devicetree/bindings/crypto/intel,keembay-ocs-hcu.yaml
F:	drivers/crypto/keembay/Kconfig
F:	drivers/crypto/keembay/Makefile
F:	drivers/crypto/keembay/keembay-ocs-hcu-core.c
F:	drivers/crypto/keembay/ocs-hcu.c
F:	drivers/crypto/keembay/ocs-hcu.h

INTEL THUNDER BAY EMMC PHY DRIVER
M:	Nandhini Srikandan <nandhini.srikandan@intel.com>
M:	Rashmi A <rashmi.a@intel.com>
S:	Maintained
F:	Documentation/devicetree/bindings/phy/intel,phy-thunderbay-emmc.yaml
F:	drivers/phy/intel/phy-intel-thunderbay-emmc.c

INTEL MANAGEMENT ENGINE (mei)
M:	Tomas Winkler <tomas.winkler@intel.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	Documentation/driver-api/mei/*
F:	drivers/misc/mei/
F:	drivers/watchdog/mei_wdt.c
F:	include/linux/mei_aux.h
F:	include/linux/mei_cl_bus.h
F:	include/uapi/linux/mei.h
F:	samples/mei/*

INTEL MAX 10 BMC MFD DRIVER
M:	Xu Yilun <yilun.xu@intel.com>
R:	Tom Rix <trix@redhat.com>
S:	Maintained
F:	Documentation/ABI/testing/sysfs-driver-intel-m10-bmc
F:	Documentation/hwmon/intel-m10-bmc-hwmon.rst
F:	drivers/hwmon/intel-m10-bmc-hwmon.c
F:	drivers/mfd/intel-m10-bmc.c
F:	include/linux/mfd/intel-m10-bmc.h

INTEL MENLOW THERMAL DRIVER
M:	Sujith Thomas <sujith.thomas@intel.com>
L:	linux-pm@vger.kernel.org
S:	Supported
W:	https://01.org/linux-acpi
F:	drivers/thermal/intel/intel_menlow.c

INTEL P-Unit IPC DRIVER
M:	Zha Qipeng <qipeng.zha@intel.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	arch/x86/include/asm/intel_punit_ipc.h
F:	drivers/platform/x86/intel/punit_ipc.c

INTEL PMC CORE DRIVER
M:	Rajneesh Bhardwaj <irenic.rajneesh@gmail.com>
M:	David E Box <david.e.box@intel.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-platform-intel-pmc
F:	drivers/platform/x86/intel/pmc/

INTEL PMIC GPIO DRIVERS
M:	Andy Shevchenko <andy@kernel.org>
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/andy/linux-gpio-intel.git
F:	drivers/gpio/gpio-*cove.c

INTEL PMIC MULTIFUNCTION DEVICE DRIVERS
M:	Andy Shevchenko <andy@kernel.org>
S:	Maintained
F:	drivers/mfd/intel_soc_pmic*
F:	include/linux/mfd/intel_soc_pmic*

INTEL PMT DRIVERS
M:	David E. Box <david.e.box@linux.intel.com>
S:	Supported
F:	drivers/platform/x86/intel/pmt/

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/device_drivers/wifi/intel/ipw2100.rst
F:	Documentation/networking/device_drivers/wifi/intel/ipw2200.rst
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 QUADRATURE ENCODER PERIPHERAL DRIVER
M:	Jarkko Nikula <jarkko.nikula@linux.intel.com>
L:	linux-iio@vger.kernel.org
F:	drivers/counter/intel-qep.c

INTEL SCU DRIVERS
M:	Mika Westerberg <mika.westerberg@linux.intel.com>
S:	Maintained
F:	arch/x86/include/asm/intel_scu_ipc.h
F:	drivers/platform/x86/intel_scu_*

INTEL SDSI DRIVER
M:	David E. Box <david.e.box@linux.intel.com>
S:	Supported
F:	drivers/platform/x86/intel/sdsi.c
F:	tools/arch/x86/intel_sdsi/
F:	tools/testing/selftests/drivers/sdsi/

INTEL SKYLAKE INT3472 ACPI DEVICE DRIVER
M:	Daniel Scally <djrscally@gmail.com>
S:	Maintained
F:	drivers/platform/x86/intel/int3472/

INTEL SPEED SELECT TECHNOLOGY
M:	Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/intel/speed_select_if/
F:	include/uapi/linux/isst_if.h
F:	tools/power/x86/intel-speed-select/

INTEL STRATIX10 FIRMWARE DRIVERS
M:	Dinh Nguyen <dinguyen@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-devices-platform-stratix10-rsu
F:	Documentation/devicetree/bindings/firmware/intel,stratix10-svc.txt
F:	drivers/firmware/stratix10-rsu.c
F:	drivers/firmware/stratix10-svc.c
F:	include/linux/firmware/intel/stratix10-smc.h
F:	include/linux/firmware/intel/stratix10-svc-client.h
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dinguyen/linux.git

INTEL TELEMETRY DRIVER
M:	Rajneesh Bhardwaj <irenic.rajneesh@gmail.com>
M:	"David E. Box" <david.e.box@linux.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 UNCORE FREQUENCY CONTROL
M:	Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	Documentation/admin-guide/pm/intel_uncore_frequency_scaling.rst
F:	drivers/platform/x86/intel/uncore-frequency/

INTEL VENDOR SPECIFIC EXTENDED CAPABILITIES DRIVER
M:	David E. Box <david.e.box@linux.intel.com>
S:	Supported
F:	drivers/platform/x86/intel/vsec.*

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 <stf_xl@wp.pl>
L:	linux-wireless@vger.kernel.org
S:	Supported
F:	drivers/net/wireless/intel/iwlegacy/

INTEL WIRELESS WIFI LINK (iwlwifi)
M:	Gregory Greenman <gregory.greenman@intel.com>
L:	linux-wireless@vger.kernel.org
S:	Supported
W:	https://wireless.wiki.kernel.org/en/users/drivers/iwlwifi
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/iwlwifi/iwlwifi.git
F:	drivers/net/wireless/intel/iwlwifi/

INTEL WMI SLIM BOOTLOADER (SBL) FIRMWARE UPDATE DRIVER
M:	Jithu Joseph <jithu.joseph@intel.com>
R:	Maurice Ma <maurice.ma@intel.com>
S:	Maintained
W:	https://slimbootloader.github.io/security/firmware-update.html
F:	drivers/platform/x86/intel/wmi/sbl-fw-update.c

INTEL WMI THUNDERBOLT FORCE POWER DRIVER
L:	Dell.Client.Kernel@dell.com
S:	Maintained
F:	drivers/platform/x86/intel/wmi/thunderbolt.c

INTEL WWAN IOSM DRIVER
M:	M Chetan Kumar <m.chetan.kumar@intel.com>
M:	Intel Corporation <linuxwwan@intel.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/wwan/iosm/

INTEL(R) TRACE HUB
M:	Alexander Shishkin <alexander.shishkin@linux.intel.com>
S:	Supported
F:	Documentation/trace/intel_th.rst
F:	drivers/hwtracing/intel_th/
F:	include/linux/intel_th.h

INTEL(R) TRUSTED EXECUTION TECHNOLOGY (TXT)
M:	Ning Sun <ning.sun@intel.com>
L:	tboot-devel@lists.sourceforge.net
S:	Supported
W:	http://tboot.sourceforge.net
T:	hg http://tboot.hg.sourceforge.net:8000/hgroot/tboot/tboot
F:	Documentation/x86/intel_txt.rst
F:	arch/x86/kernel/tboot.c
F:	include/linux/tboot.h

INTEL SGX
M:	Jarkko Sakkinen <jarkko@kernel.org>
R:	Dave Hansen <dave.hansen@linux.intel.com>
L:	linux-sgx@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/intel-sgx/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86/sgx
F:	Documentation/x86/sgx.rst
F:	arch/x86/entry/vdso/vsgx.S
F:	arch/x86/include/asm/sgx.h
F:	arch/x86/include/uapi/asm/sgx.h
F:	arch/x86/kernel/cpu/sgx/*
F:	tools/testing/selftests/sgx/*
K:	\bSGX_

INTERCONNECT API
M:	Georgi Djakov <djakov@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/djakov/icc.git
F:	Documentation/devicetree/bindings/interconnect/
F:	Documentation/driver-api/interconnect.rst
F:	drivers/interconnect/
F:	include/dt-bindings/interconnect/
F:	include/linux/interconnect-provider.h
F:	include/linux/interconnect.h

INTERRUPT COUNTER DRIVER
M:	Oleksij Rempel <o.rempel@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
L:	linux-iio@vger.kernel.org
F:	Documentation/devicetree/bindings/counter/interrupt-counter.yaml
F:	drivers/counter/interrupt-cnt.c

INTERSIL ISL7998X VIDEO DECODER DRIVER
M:	Michael Tretter <m.tretter@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/i2c/isil,isl79987.yaml
F:	drivers/media/i2c/isl7998x.c

INVENSENSE ICM-426xx IMU DRIVER
M:	Jean-Baptiste Maneyrol <jmaneyrol@invensense.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
W:	https://invensense.tdk.com/
F:	Documentation/devicetree/bindings/iio/imu/invensense,icm42600.yaml
F:	drivers/iio/imu/inv_icm42600/

INVENSENSE MPU-3050 GYROSCOPE DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/gyroscope/invensense,mpu3050.yaml
F:	drivers/iio/gyro/mpu3050*

IOC3 ETHERNET DRIVER
M:	Ralf Baechle <ralf@linux-mips.org>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/sgi/ioc3-eth.c

IOMAP FILESYSTEM LIBRARY
M:	Christoph Hellwig <hch@infradead.org>
M:	Darrick J. Wong <djwong@kernel.org>
L:	linux-xfs@vger.kernel.org
L:	linux-fsdevel@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/fs/xfs/xfs-linux.git
F:	fs/iomap/
F:	include/linux/iomap.h

IOMMU DRIVERS
M:	Joerg Roedel <joro@8bytes.org>
M:	Will Deacon <will@kernel.org>
L:	iommu@lists.linux.dev
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu.git
F:	Documentation/devicetree/bindings/iommu/
F:	Documentation/userspace-api/iommu.rst
F:	drivers/iommu/
F:	include/linux/iommu.h
F:	include/linux/iova.h
F:	include/linux/of_iommu.h
F:	include/uapi/linux/iommu.h

IOSYS-MAP HELPERS
M:	Thomas Zimmermann <tzimmermann@suse.de>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	include/linux/iosys-map.h

IO_URING
M:	Jens Axboe <axboe@kernel.dk>
R:	Pavel Begunkov <asml.silence@gmail.com>
L:	io-uring@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.dk/linux-block
T:	git git://git.kernel.dk/liburing
F:	io_uring/
F:	include/linux/io_uring.h
F:	include/uapi/linux/io_uring.h
F:	tools/io_uring/

IPMI SUBSYSTEM
M:	Corey Minyard <minyard@acm.org>
L:	openipmi-developer@lists.sourceforge.net (moderated for non-subscribers)
S:	Supported
W:	http://openipmi.sourceforge.net/
T:	git https://github.com/cminyard/linux-ipmi.git for-next
F:	Documentation/driver-api/ipmi.rst
F:	Documentation/devicetree/bindings/ipmi/
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
S:	Maintained
W:	http://www.adaptec.com/
F:	drivers/scsi/ips*

IPVS
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.rst
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/

IRQ DOMAINS (IRQ NUMBER MAPPING LIBRARY)
M:	Marc Zyngier <maz@kernel.org>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git irq/core
F:	Documentation/core-api/irq/irq-domain.rst
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:	Marc Zyngier <maz@kernel.org>
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 <william.gray@linaro.org>
S:	Maintained
F:	Documentation/driver-api/isa.rst
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
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/radio/radio-isa*

ISAPNP
M:	Jaroslav Kysela <perex@perex.cz>
S:	Maintained
F:	Documentation/driver-api/isapnp.rst
F:	drivers/pnp/isapnp/
F:	include/linux/isapnp.h

ISCSI
M:	Lee Duncan <lduncan@suse.com>
M:	Chris Leech <cleech@redhat.com>
M:	Mike Christie <michael.christie@oracle.com>
L:	open-iscsi@googlegroups.com
L:	linux-scsi@vger.kernel.org
S:	Maintained
W:	www.open-iscsi.com
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:	Sagi Grimberg <sagi@grimberg.me>
M:	Max Gurtovoy <mgurtovoy@nvidia.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>
L:	linux-rdma@vger.kernel.org
L:	target-devel@vger.kernel.org
S:	Supported
W:	http://www.linux-iscsi.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending.git master
F:	drivers/infiniband/ulp/isert

ISDN/CMTP OVER BLUETOOTH
M:	Karsten Keil <isdn@linux-pingi.de>
L:	isdn4linux@listserv.isdn4linux.de (subscribers-only)
L:	netdev@vger.kernel.org
S:	Odd Fixes
W:	http://www.isdn4linux.de
F:	Documentation/isdn/
F:	drivers/isdn/capi/
F:	include/linux/isdn/
F:	include/uapi/linux/isdn/
F:	net/bluetooth/cmtp/

ISDN/mISDN SUBSYSTEM
M:	Karsten Keil <isdn@linux-pingi.de>
L:	isdn4linux@listserv.isdn4linux.de (subscribers-only)
L:	netdev@vger.kernel.org
S:	Maintained
W:	http://www.isdn4linux.de
F:	drivers/isdn/Kconfig
F:	drivers/isdn/Makefile
F:	drivers/isdn/hardware/
F:	drivers/isdn/mISDN/

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

IT913X MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/tuners/it913x*

ITE IT66121 HDMI BRIDGE DRIVER
M:	Phong LE <ple@baylibre.com>
M:	Neil Armstrong <narmstrong@baylibre.com>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/bridge/ite,it66121.yaml
F:	drivers/gpu/drm/bridge/ite-it66121.c

IVTV VIDEO4LINUX DRIVER
M:	Andy Walls <awalls@md.metrocast.net>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/admin-guide/media/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
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
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/include/asm/jailhouse_para.h
F:	arch/x86/kernel/jailhouse.c

JC42.4 TEMPERATURE SENSOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/hwmon/jedec,jc42.yaml
F:	Documentation/hwmon/jc42.rst
F:	drivers/hwmon/jc42.c

JFS FILESYSTEM
M:	Dave Kleikamp <shaggy@kernel.org>
L:	jfs-discussion@lists.sourceforge.net
S:	Maintained
W:	http://jfs.sourceforge.net/
T:	git git://github.com/kleikamp/linux-shaggy.git
F:	Documentation/admin-guide/jfs.rst
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>
M:	Richard Weinberger <richard@nod.at>
L:	linux-mtd@lists.infradead.org
S:	Odd Fixes
W:	http://www.linux-mtd.infradead.org/doc/jffs2.html
T:	git git://git.infradead.org/ubifs-2.6.git
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
L:	linux-renesas-soc@vger.kernel.org
S:	Maintained
F:	drivers/media/platform/renesas/rcar_jpu.c

JSM Neo PCI based serial card
L:	linux-serial@vger.kernel.org
S:	Orphan
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.rst
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.rst
F:	drivers/hwmon/k8temp.c

KASAN
M:	Andrey Ryabinin <ryabinin.a.a@gmail.com>
R:	Alexander Potapenko <glider@google.com>
R:	Andrey Konovalov <andreyknvl@gmail.com>
R:	Dmitry Vyukov <dvyukov@google.com>
R:	Vincenzo Frascino <vincenzo.frascino@arm.com>
L:	kasan-dev@googlegroups.com
S:	Maintained
F:	Documentation/dev-tools/kasan.rst
F:	arch/*/include/asm/*kasan.h
F:	arch/*/mm/kasan_init*
F:	include/linux/kasan*.h
F:	lib/Kconfig.kasan
F:	lib/test_kasan*.c
F:	mm/kasan/
F:	scripts/Makefile.kasan

KCONFIG
M:	Masahiro Yamada <masahiroy@kernel.org>
L:	linux-kbuild@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git kconfig
F:	Documentation/kbuild/kconfig*
F:	scripts/Kconfig.include
F:	scripts/kconfig/

KCOV
R:	Dmitry Vyukov <dvyukov@google.com>
R:	Andrey Konovalov <andreyknvl@gmail.com>
L:	kasan-dev@googlegroups.com
S:	Maintained
F:	Documentation/dev-tools/kcov.rst
F:	include/linux/kcov.h
F:	include/uapi/linux/kcov.h
F:	kernel/kcov.c
F:	scripts/Makefile.kcov

KCSAN
M:	Marco Elver <elver@google.com>
R:	Dmitry Vyukov <dvyukov@google.com>
L:	kasan-dev@googlegroups.com
S:	Maintained
F:	Documentation/dev-tools/kcsan.rst
F:	include/linux/kcsan*.h
F:	kernel/kcsan/
F:	lib/Kconfig.kcsan
F:	scripts/Makefile.kcsan

KDUMP
M:	Baoquan He <bhe@redhat.com>
R:	Vivek Goyal <vgoyal@redhat.com>
R:	Dave Young <dyoung@redhat.com>
L:	kexec@lists.infradead.org
S:	Maintained
W:	http://lse.sourceforge.net/kdump/
F:	Documentation/admin-guide/kdump/
F:	fs/proc/vmcore.c
F:	include/linux/crash_core.h
F:	include/linux/crash_dump.h
F:	include/uapi/linux/vmcore.h
F:	kernel/crash_*.c

KEENE FM RADIO TRANSMITTER DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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 <masahiroy@kernel.org>
M:	Michal Marek <michal.lkml@markovi.net>
R:	Nick Desaulniers <ndesaulniers@google.com>
L:	linux-kbuild@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/masahiroy/linux-kbuild.git
F:	Documentation/kbuild/
F:	Makefile
F:	scripts/*vmlinux*
F:	scripts/Kbuild*
F:	scripts/Makefile*
F:	scripts/basic/
F:	scripts/dummy-tools/
F:	scripts/mk*
F:	scripts/mod/
F:	scripts/package/

KERNEL HARDENING (not covered by other areas)
M:	Kees Cook <keescook@chromium.org>
L:	linux-hardening@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
F:	include/linux/overflow.h
F:	include/linux/randomize_kstack.h
F:	mm/usercopy.c
K:	\b(add|choose)_random_kstack_offset\b
K:	\b__check_(object_size|heap_object)\b

KERNEL JANITORS
L:	kernel-janitors@vger.kernel.org
S:	Odd Fixes
W:	http://kernelnewbies.org/KernelJanitors

KERNEL NFSD, SUNRPC, AND LOCKD SERVERS
M:	Chuck Lever <chuck.lever@oracle.com>
M:	Jeff Layton <jlayton@kernel.org>
L:	linux-nfs@vger.kernel.org
S:	Supported
W:	http://nfs.sourceforge.net/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/cel/linux.git
F:	fs/lockd/
F:	fs/nfs_common/
F:	fs/nfsd/
F:	include/linux/lockd/
F:	include/linux/sunrpc/
F:	include/uapi/linux/nfsd/
F:	include/uapi/linux/sunrpc/
F:	net/sunrpc/
F:	Documentation/filesystems/nfs/

KERNEL REGRESSIONS
M:	Thorsten Leemhuis <linux@leemhuis.info>
L:	regressions@lists.linux.dev
S:	Supported
F:	Documentation/admin-guide/reporting-regressions.rst
F:	Documentation/process/handling-regressions.rst

KERNEL SELFTEST FRAMEWORK
M:	Shuah Khan <shuah@kernel.org>
M:	Shuah Khan <skhan@linuxfoundation.org>
L:	linux-kselftest@vger.kernel.org
S:	Maintained
Q:	https://patchwork.kernel.org/project/linux-kselftest/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest.git
F:	Documentation/dev-tools/kselftest*
F:	tools/testing/selftests/

KERNEL SMB3 SERVER (KSMBD)
M:	Namjae Jeon <linkinjeon@kernel.org>
M:	Steve French <sfrench@samba.org>
M:	Hyunchul Lee <hyc.lee@gmail.com>
R:	Sergey Senozhatsky <senozhatsky@chromium.org>
L:	linux-cifs@vger.kernel.org
S:	Maintained
T:	git git://git.samba.org/ksmbd.git
F:	fs/ksmbd/
F:	fs/smbfs_common/

KERNEL UNIT TESTING FRAMEWORK (KUnit)
M:	Brendan Higgins <brendanhiggins@google.com>
L:	linux-kselftest@vger.kernel.org
L:	kunit-dev@googlegroups.com
S:	Maintained
W:	https://google.github.io/kunit-docs/third_party/kernel/docs/
F:	Documentation/dev-tools/kunit/
F:	include/kunit/
F:	lib/kunit/
F:	tools/testing/kunit/

KERNEL USERMODE HELPER
M:	Luis Chamberlain <mcgrof@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	include/linux/umh.h
F:	kernel/umh.c

KERNEL VIRTUAL MACHINE (KVM)
M:	Paolo Bonzini <pbonzini@redhat.com>
L:	kvm@vger.kernel.org
S:	Supported
W:	http://www.linux-kvm.org
T:	git git://git.kernel.org/pub/scm/virt/kvm/kvm.git
F:	Documentation/virt/kvm/
F:	include/asm-generic/kvm*
F:	include/kvm/iodev.h
F:	include/linux/kvm*
F:	include/trace/events/kvm.h
F:	include/uapi/asm-generic/kvm*
F:	include/uapi/linux/kvm*
F:	tools/kvm/
F:	tools/testing/selftests/kvm/
F:	virt/kvm/*

KERNEL VIRTUAL MACHINE FOR ARM64 (KVM/arm64)
M:	Marc Zyngier <maz@kernel.org>
R:	James Morse <james.morse@arm.com>
R:	Alexandru Elisei <alexandru.elisei@arm.com>
R:	Suzuki K Poulose <suzuki.poulose@arm.com>
R:	Oliver Upton <oliver.upton@linux.dev>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	kvmarm@lists.cs.columbia.edu (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvmarm/kvmarm.git
F:	arch/arm64/include/asm/kvm*
F:	arch/arm64/include/uapi/asm/kvm*
F:	arch/arm64/kvm/
F:	include/kvm/arm_*
F:	tools/testing/selftests/kvm/*/aarch64/
F:	tools/testing/selftests/kvm/aarch64/

KERNEL VIRTUAL MACHINE FOR MIPS (KVM/mips)
M:	Huacai Chen <chenhuacai@kernel.org>
M:	Aleksandar Markovic <aleksandar.qemu.devel@gmail.com>
L:	linux-mips@vger.kernel.org
L:	kvm@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/virt/kvm/kvm.git
F:	arch/mips/include/asm/kvm*
F:	arch/mips/include/uapi/asm/kvm*
F:	arch/mips/kvm/

KERNEL VIRTUAL MACHINE FOR POWERPC (KVM/powerpc)
L:	linuxppc-dev@lists.ozlabs.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git topic/ppc-kvm
F:	arch/powerpc/include/asm/kvm*
F:	arch/powerpc/include/uapi/asm/kvm*
F:	arch/powerpc/kernel/kvm*
F:	arch/powerpc/kvm/

KERNEL VIRTUAL MACHINE FOR RISC-V (KVM/riscv)
M:	Anup Patel <anup@brainfault.org>
R:	Atish Patra <atishp@atishpatra.org>
L:	kvm@vger.kernel.org
L:	kvm-riscv@lists.infradead.org
L:	linux-riscv@lists.infradead.org
S:	Maintained
T:	git git://github.com/kvm-riscv/linux.git
F:	arch/riscv/include/asm/kvm*
F:	arch/riscv/include/uapi/asm/kvm*
F:	arch/riscv/kvm/
F:	tools/testing/selftests/kvm/*/riscv/

KERNEL VIRTUAL MACHINE for s390 (KVM/s390)
M:	Christian Borntraeger <borntraeger@linux.ibm.com>
M:	Janosch Frank <frankja@linux.ibm.com>
M:	Claudio Imbrenda <imbrenda@linux.ibm.com>
R:	David Hildenbrand <david@redhat.com>
L:	kvm@vger.kernel.org
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvms390/linux.git
F:	Documentation/virt/kvm/s390*
F:	arch/s390/include/asm/gmap.h
F:	arch/s390/include/asm/kvm*
F:	arch/s390/include/uapi/asm/kvm*
F:	arch/s390/include/uapi/asm/uvdevice.h
F:	arch/s390/kernel/uv.c
F:	arch/s390/kvm/
F:	arch/s390/mm/gmap.c
F:	drivers/s390/char/uvdevice.c
F:	tools/testing/selftests/drivers/s390x/uvdevice/
F:	tools/testing/selftests/kvm/*/s390x/
F:	tools/testing/selftests/kvm/s390x/

KERNEL VIRTUAL MACHINE FOR X86 (KVM/x86)
M:	Sean Christopherson <seanjc@google.com>
M:	Paolo Bonzini <pbonzini@redhat.com>
L:	kvm@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/virt/kvm/kvm.git
F:	arch/x86/include/asm/kvm*
F:	arch/x86/include/asm/svm.h
F:	arch/x86/include/asm/vmx*.h
F:	arch/x86/include/uapi/asm/kvm*
F:	arch/x86/include/uapi/asm/svm.h
F:	arch/x86/include/uapi/asm/vmx.h
F:	arch/x86/kvm/
F:	arch/x86/kvm/*/

KVM PARAVIRT (KVM/paravirt)
M:	Paolo Bonzini <pbonzini@redhat.com>
R:	Wanpeng Li <wanpengli@tencent.com>
R:	Vitaly Kuznetsov <vkuznets@redhat.com>
L:	kvm@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/virt/kvm/kvm.git
F:	arch/x86/kernel/kvm.c
F:	arch/x86/kernel/kvmclock.c
F:	arch/x86/include/asm/pvclock-abi.h
F:	include/linux/kvm_para.h
F:	include/uapi/linux/kvm_para.h
F:	include/uapi/asm-generic/kvm_para.h
F:	include/asm-generic/kvm_para.h
F:	arch/um/include/asm/kvm_para.h
F:	arch/x86/include/asm/kvm_para.h
F:	arch/x86/include/uapi/asm/kvm_para.h

KVM X86 HYPER-V (KVM/hyper-v)
M:	Vitaly Kuznetsov <vkuznets@redhat.com>
M:	Sean Christopherson <seanjc@google.com>
M:	Paolo Bonzini <pbonzini@redhat.com>
L:	kvm@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/virt/kvm/kvm.git
F:	arch/x86/kvm/hyperv.*
F:	arch/x86/kvm/kvm_onhyperv.*
F:	arch/x86/kvm/svm/hyperv.*
F:	arch/x86/kvm/svm/svm_onhyperv.*
F:	arch/x86/kvm/vmx/evmcs.*

KERNFS
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
M:	Tejun Heo <tj@kernel.org>
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core.git
F:	fs/kernfs/
F:	include/linux/kernfs.h

KEXEC
M:	Eric Biederman <ebiederm@xmission.com>
L:	kexec@lists.infradead.org
S:	Maintained
W:	http://kernel.org/pub/linux/utils/kernel/kexec/
F:	include/linux/kexec.h
F:	include/uapi/linux/kexec.h
F:	kernel/kexec*

KEYS-ENCRYPTED
M:	Mimi Zohar <zohar@linux.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.ibm.com>
M:	Jarkko Sakkinen <jarkko@kernel.org>
M:	Mimi Zohar <zohar@linux.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:	include/keys/trusted_tpm.h
F:	security/keys/trusted-keys/

KEYS-TRUSTED-TEE
M:	Sumit Garg <sumit.garg@linaro.org>
L:	linux-integrity@vger.kernel.org
L:	keyrings@vger.kernel.org
S:	Supported
F:	include/keys/trusted_tee.h
F:	security/keys/trusted-keys/trusted_tee.c

KEYS-TRUSTED-CAAM
M:	Ahmad Fatoum <a.fatoum@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
L:	linux-integrity@vger.kernel.org
L:	keyrings@vger.kernel.org
S:	Maintained
F:	include/keys/trusted_caam.h
F:	security/keys/trusted-keys/trusted_caam.c

KEYS/KEYRINGS
M:	David Howells <dhowells@redhat.com>
M:	Jarkko Sakkinen <jarkko@kernel.org>
L:	keyrings@vger.kernel.org
S:	Maintained
F:	Documentation/security/keys/core.rst
F:	include/keys/
F:	include/linux/key-type.h
F:	include/linux/key.h
F:	include/linux/keyctl.h
F:	include/uapi/linux/keyctl.h
F:	security/keys/

KEYS/KEYRINGS_INTEGRITY
M:	Jarkko Sakkinen <jarkko@kernel.org>
M:	Mimi Zohar <zohar@linux.ibm.com>
L:	linux-integrity@vger.kernel.org
L:	keyrings@vger.kernel.org
S:	Supported
F:	security/integrity/platform_certs

KFENCE
M:	Alexander Potapenko <glider@google.com>
M:	Marco Elver <elver@google.com>
R:	Dmitry Vyukov <dvyukov@google.com>
L:	kasan-dev@googlegroups.com
S:	Maintained
F:	Documentation/dev-tools/kfence.rst
F:	arch/*/include/asm/kfence.h
F:	include/linux/kfence.h
F:	lib/Kconfig.kfence
F:	mm/kfence/

KFIFO
M:	Stefani Seibold <stefani@seibold.net>
S:	Maintained
F:	include/linux/kfifo.h
F:	lib/kfifo.c
F:	samples/kfifo/

KGDB / KDB /debug_core
M:	Jason Wessel <jason.wessel@windriver.com>
M:	Daniel Thompson <daniel.thompson@linaro.org>
R:	Douglas Anderson <dianders@chromium.org>
L:	kgdb-bugreport@lists.sourceforge.net
S:	Maintained
W:	http://kgdb.wiki.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/kgdb.git
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/
F:	kernel/module/kdb.c

KHADAS MCU MFD DRIVER
M:	Neil Armstrong <narmstrong@baylibre.com>
L:	linux-amlogic@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/mfd/khadas,mcu.yaml
F:	drivers/mfd/khadas-mcu.c
F:	include/linux/mfd/khadas-mcu.h
F:	drivers/thermal/khadas_mcu_fan.c

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:	samples/kmemleak/kmemleak-test.c

KMOD KERNEL MODULE LOADER - USERMODE HELPER
M:	Luis Chamberlain <mcgrof@kernel.org>
L:	linux-kernel@vger.kernel.org
L:	linux-modules@vger.kernel.org
S:	Maintained
F:	include/linux/kmod.h
F:	kernel/kmod.c
F:	lib/test_kmod.c
F:	tools/testing/selftests/kmod/

KPROBES
M:	Naveen N. Rao <naveen.n.rao@linux.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
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
F:	Documentation/trace/kprobes.rst
F:	include/asm-generic/kprobes.h
F:	include/linux/kprobes.h
F:	kernel/kprobes.c
F:	lib/test_kprobes.c
F:	samples/kprobes

KS0108 LCD CONTROLLER DRIVER
M:	Miguel Ojeda <ojeda@kernel.org>
S:	Maintained
F:	Documentation/admin-guide/auxdisplay/ks0108.rst
F:	drivers/auxdisplay/ks0108.c
F:	include/linux/ks0108.h

KTD253 BACKLIGHT DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
S:	Maintained
F:	Documentation/devicetree/bindings/leds/backlight/kinetic,ktd253.yaml
F:	drivers/video/backlight/ktd253-backlight.c

KTEST
M:	Steven Rostedt <rostedt@goodmis.org>
M:	John Hawley <warthog9@eaglescrag.net>
S:	Maintained
F:	tools/testing/ktest

L3MDEV
M:	David Ahern <dsahern@kernel.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	include/net/l3mdev.h
F:	net/l3mdev

LANDLOCK SECURITY MODULE
M:	Mickaël Salaün <mic@digikod.net>
L:	linux-security-module@vger.kernel.org
S:	Supported
W:	https://landlock.io
T:	git https://github.com/landlock-lsm/linux.git
F:	Documentation/security/landlock.rst
F:	Documentation/userspace-api/landlock.rst
F:	include/uapi/linux/landlock.h
F:	samples/landlock/
F:	security/landlock/
F:	tools/testing/selftests/landlock/
K:	landlock
K:	LANDLOCK

LANTIQ / INTEL Ethernet drivers
M:	Hauke Mehrtens <hauke@hauke-m.de>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/dsa/lantiq_gswip.c
F:	drivers/net/dsa/lantiq_pce.h
F:	drivers/net/ethernet/lantiq_xrx200.c
F:	net/dsa/tag_gswip.c

LANTIQ MIPS ARCHITECTURE
M:	John Crispin <john@phrozen.org>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	arch/mips/lantiq
F:	drivers/soc/lantiq

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.rst
F:	drivers/scsi/53c700*

LEAKING_ADDRESSES
M:	Tobin C. Harding <me@tobin.cc>
M:	Tycho Andersen <tycho@tycho.pizza>
L:	linux-hardening@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tobin/leaks.git
F:	scripts/leaking_addresses.pl

LED SUBSYSTEM
M:	Pavel Machek <pavel@ucw.cz>
L:	linux-leds@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pavel/linux-leds.git
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.rst
F:	drivers/misc/eeprom/eeprom.c

LEGO MINDSTORMS EV3
R:	David Lechner <david@lechnology.com>
S:	Maintained
F:	Documentation/devicetree/bindings/power/supply/lego,ev3-battery.yaml
F:	arch/arm/boot/dts/da850-lego-ev3.dts
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
S:	Maintained
W:	http://legousb.sourceforge.net/
F:	drivers/usb/misc/legousbtower.c

LETSKETCH HID TABLET DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-input@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid.git
F:	drivers/hid/hid-letsketch.c

LG LAPTOP EXTRAS
M:	Matan Ziv-Av <matan@svgalib.org>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-platform-lg-laptop
F:	Documentation/admin-guide/laptops/lg-laptop.rst
F:	drivers/platform/x86/lg-laptop.c

LG2160 MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/lg2160.*

LGDT3305 MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/lgdt3305.*

LIBATA PATA ARASAN COMPACT FLASH CONTROLLER
M:	Viresh Kumar <vireshk@kernel.org>
L:	linux-ide@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git
F:	drivers/ata/pata_arasan_cf.c
F:	include/linux/pata_arasan_cf_data.h

LIBATA PATA DRIVERS
R:	Sergey Shtylyov <s.shtylyov@omp.ru>
L:	linux-ide@vger.kernel.org
F:	drivers/ata/ata_*.c
F:	drivers/ata/pata_*.c

LIBATA PATA FARADAY FTIDE010 AND GEMINI SATA BRIDGE DRIVERS
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-ide@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git
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:	Jens Axboe <axboe@kernel.dk>
L:	linux-ide@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git
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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git
F:	drivers/ata/sata_promise.*

LIBATA SUBSYSTEM (Serial and Parallel ATA drivers)
M:	Damien Le Moal <damien.lemoal@opensource.wdc.com>
L:	linux-ide@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dlemoal/libata.git
F:	Documentation/ABI/testing/sysfs-ata
F:	Documentation/devicetree/bindings/ata/
F:	drivers/ata/
F:	include/linux/ata.h
F:	include/linux/libata.h

LIBNVDIMM BTT: BLOCK TRANSLATION TABLE
M:	Vishal Verma <vishal.l.verma@intel.com>
M:	Dan Williams <dan.j.williams@intel.com>
M:	Dave Jiang <dave.jiang@intel.com>
L:	nvdimm@lists.linux.dev
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-nvdimm/list/
P:	Documentation/nvdimm/maintainer-entry-profile.rst
F:	drivers/nvdimm/btt*

LIBNVDIMM PMEM: PERSISTENT MEMORY DRIVER
M:	Dan Williams <dan.j.williams@intel.com>
M:	Vishal Verma <vishal.l.verma@intel.com>
M:	Dave Jiang <dave.jiang@intel.com>
L:	nvdimm@lists.linux.dev
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-nvdimm/list/
P:	Documentation/nvdimm/maintainer-entry-profile.rst
F:	drivers/nvdimm/pmem*

LIBNVDIMM: DEVICETREE BINDINGS
M:	Oliver O'Halloran <oohall@gmail.com>
L:	nvdimm@lists.linux.dev
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-nvdimm/list/
F:	Documentation/devicetree/bindings/pmem/pmem-region.txt
F:	drivers/nvdimm/of_pmem.c

LIBNVDIMM: NON-VOLATILE MEMORY DEVICE SUBSYSTEM
M:	Dan Williams <dan.j.williams@intel.com>
M:	Vishal Verma <vishal.l.verma@intel.com>
M:	Dave Jiang <dave.jiang@intel.com>
M:	Ira Weiny <ira.weiny@intel.com>
L:	nvdimm@lists.linux.dev
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-nvdimm/list/
P:	Documentation/nvdimm/maintainer-entry-profile.rst
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm.git
F:	drivers/acpi/nfit/*
F:	drivers/nvdimm/*
F:	include/linux/libnvdimm.h
F:	include/linux/nd.h
F:	include/uapi/linux/ndctl.h
F:	tools/testing/nvdimm/

LICENSES and SPDX stuff
M:	Thomas Gleixner <tglx@linutronix.de>
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
L:	linux-spdx@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/spdx.git
F:	COPYING
F:	Documentation/process/license-rules.rst
F:	LICENSES/
F:	scripts/spdxcheck-test.sh
F:	scripts/spdxcheck.py

LINEAR RANGES HELPERS
M:	Mark Brown <broonie@kernel.org>
R:	Matti Vaittinen <mazziesaccount@gmail.com>
F:	lib/linear_ranges.c
F:	lib/test_linear_ranges.c
F:	include/linux/linear_range.h

LINUX FOR POWER MACINTOSH
M:	Benjamin Herrenschmidt <benh@kernel.crashing.org>
L:	linuxppc-dev@lists.ozlabs.org
S:	Odd Fixes
F:	arch/powerpc/platforms/powermac/
F:	drivers/macintosh/

LINUX FOR POWERPC (32-BIT AND 64-BIT)
M:	Michael Ellerman <mpe@ellerman.id.au>
R:	Benjamin Herrenschmidt <benh@kernel.crashing.org>
R:	Paul Mackerras <paulus@samba.org>
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
W:	https://github.com/linuxppc/wiki/wiki
Q:	http://patchwork.ozlabs.org/project/linuxppc-dev/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git
F:	Documentation/ABI/stable/sysfs-firmware-opal-*
F:	Documentation/devicetree/bindings/i2c/i2c-opal.txt
F:	Documentation/devicetree/bindings/powerpc/
F:	Documentation/devicetree/bindings/rtc/rtc-opal.txt
F:	Documentation/powerpc/
F:	arch/powerpc/
F:	drivers/*/*/*pasemi*
F:	drivers/*/*pasemi*
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
S:	Odd Fixes
F:	arch/powerpc/platforms/512x/
F:	arch/powerpc/platforms/52xx/

LINUX FOR POWERPC EMBEDDED PPC4XX
L:	linuxppc-dev@lists.ozlabs.org
S:	Orphan
F:	arch/powerpc/platforms/40x/
F:	arch/powerpc/platforms/44x/

LINUX FOR POWERPC EMBEDDED PPC83XX AND PPC85XX
M:	Scott Wood <oss@buserror.net>
L:	linuxppc-dev@lists.ozlabs.org
S:	Odd fixes
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/scottwood/linux.git
F:	Documentation/devicetree/bindings/powerpc/fsl/
F:	arch/powerpc/platforms/83xx/
F:	arch/powerpc/platforms/85xx/

LINUX FOR POWERPC EMBEDDED PPC8XX
M:	Christophe Leroy <christophe.leroy@csgroup.eu>
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	arch/powerpc/platforms/8xx/

LINUX KERNEL DUMP TEST MODULE (LKDTM)
M:	Kees Cook <keescook@chromium.org>
S:	Maintained
F:	drivers/misc/lkdtm/*
F:	tools/testing/selftests/lkdtm/*

LINUX KERNEL MEMORY CONSISTENCY MODEL (LKMM)
M:	Alan Stern <stern@rowland.harvard.edu>
M:	Andrea Parri <parri.andrea@gmail.com>
M:	Will Deacon <will@kernel.org>
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@kernel.org>
R:	Akira Yokosawa <akiyks@gmail.com>
R:	Daniel Lustig <dlustig@nvidia.com>
R:	Joel Fernandes <joel@joelfernandes.org>
L:	linux-kernel@vger.kernel.org
L:	linux-arch@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git dev
F:	Documentation/atomic_bitops.txt
F:	Documentation/atomic_t.txt
F:	Documentation/core-api/refcount-vs-atomic.rst
F:	Documentation/litmus-tests/
F:	Documentation/memory-barriers.txt
F:	tools/memory-model/

LIS3LV02D ACCELEROMETER DRIVER
M:	Eric Piel <eric.piel@tremplin-utc.net>
S:	Maintained
F:	Documentation/misc-devices/lis3lv02d.rst
F:	drivers/misc/lis3lv02d/
F:	drivers/platform/x86/hp_accel.c

LIST KUNIT TEST
M:	David Gow <davidgow@google.com>
L:	linux-kselftest@vger.kernel.org
L:	kunit-dev@googlegroups.com
S:	Maintained
F:	lib/list-test.c

LITEX PLATFORM
M:	Karol Gugala <kgugala@antmicro.com>
M:	Mateusz Holenko <mholenko@antmicro.com>
M:	Gabriel Somlo <gsomlo@gmail.com>
M:	Joel Stanley <joel@jms.id.au>
S:	Maintained
F:	Documentation/devicetree/bindings/*/litex,*.yaml
F:	arch/openrisc/boot/dts/or1klitex.dts
F:	include/linux/litex.h
F:	drivers/tty/serial/liteuart.c
F:	drivers/soc/litex/*
F:	drivers/net/ethernet/litex/*
F:	drivers/mmc/host/litex_mmc.c
N:	litex

LIVE PATCHING
M:	Josh Poimboeuf <jpoimboe@kernel.org>
M:	Jiri Kosina <jikos@kernel.org>
M:	Miroslav Benes <mbenes@suse.cz>
M:	Petr Mladek <pmladek@suse.com>
R:	Joe Lawrence <joe.lawrence@redhat.com>
L:	live-patching@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/livepatching/livepatching.git
F:	Documentation/ABI/testing/sysfs-kernel-livepatch
F:	Documentation/livepatch/
F:	arch/powerpc/include/asm/livepatch.h
F:	include/linux/livepatch.h
F:	kernel/livepatch/
F:	kernel/module/livepatch.c
F:	lib/livepatch/
F:	samples/livepatch/
F:	tools/testing/selftests/livepatch/

LLC (802.2)
L:	netdev@vger.kernel.org
S:	Odd fixes
F:	include/linux/llc.h
F:	include/net/llc*
F:	include/uapi/linux/llc.h
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.rst
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.rst
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/devicetree/bindings/hwmon/national,lm90.yaml
F:	Documentation/hwmon/lm90.rst
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.rst
F:	drivers/hwmon/lm95234.c

LME2510 MEDIA DRIVER
M:	Malcolm Priestley <tvboxspy@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
F:	drivers/media/usb/dvb-usb-v2/lmedm04*

LOADPIN SECURITY MODULE
M:	Kees Cook <keescook@chromium.org>
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
F:	Documentation/admin-guide/LSM/LoadPin.rst
F:	security/loadpin/

LOCKING PRIMITIVES
M:	Peter Zijlstra <peterz@infradead.org>
M:	Ingo Molnar <mingo@redhat.com>
M:	Will Deacon <will@kernel.org>
R:	Waiman Long <longman@redhat.com>
R:	Boqun Feng <boqun.feng@gmail.com> (LOCKDEP)
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git locking/core
F:	Documentation/locking/
F:	arch/*/include/asm/spinlock*.h
F:	include/linux/lockdep.h
F:	include/linux/mutex*.h
F:	include/linux/rwlock*.h
F:	include/linux/rwsem*.h
F:	include/linux/seqlock.h
F:	include/linux/spinlock*.h
F:	kernel/locking/
F:	lib/locking*.[ch]
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
S:	Maintained
W:	http://www.linux-ntfs.org/content/view/19/37/
F:	Documentation/admin-guide/ldm.rst
F:	block/partitions/ldm.*

LOGITECH HID GAMING KEYBOARDS
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-input@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid.git
F:	drivers/hid/hid-lg-g15.c

LONTIUM LT8912B MIPI TO HDMI BRIDGE
M:	Adrien Grassein <adrien.grassein@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/display/bridge/lontium,lt8912b.yaml
F:	drivers/gpu/drm/bridge/lontium-lt8912b.c

LOONGARCH
M:	Huacai Chen <chenhuacai@kernel.org>
R:	WANG Xuerui <kernel@xen0n.name>
L:	loongarch@lists.linux.dev
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/chenhuacai/linux-loongson.git
F:	arch/loongarch/
F:	drivers/*/*loongarch*
F:	Documentation/loongarch/
F:	Documentation/translations/zh_CN/loongarch/

LSILOGIC MPT FUSION DRIVERS (FC/SAS/SPI)
M:	Sathya Prakash <sathya.prakash@broadcom.com>
M:	Sreekanth Reddy <sreekanth.reddy@broadcom.com>
M:	Suganath Prabu Subramani <suganath-prabu.subramani@broadcom.com>
L:	MPT-FusionLinux.pdl@broadcom.com
L:	linux-scsi@vger.kernel.org
S:	Supported
W:	http://www.avagotech.com/support/
F:	drivers/message/fusion/
F:	drivers/scsi/mpt3sas/

LSILOGIC/SYMBIOS/NCR 53C8XX and 53C1010 PCI-SCSI drivers
M:	Matthew Wilcox <willy@infradead.org>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/scsi/sym53c8xx_2/

LTC1660 DAC DRIVER
M:	Marcus Folkesson <marcus.folkesson@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/dac/lltc,ltc1660.yaml
F:	drivers/iio/dac/ltc1660.c

LTC2688 IIO DAC DRIVER
M:	Nuno Sá <nuno.sa@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	http://ez.analog.com/community/linux-device-drivers
F:	Documentation/ABI/testing/sysfs-bus-iio-dac-ltc2688
F:	Documentation/devicetree/bindings/iio/dac/adi,ltc2688.yaml
F:	drivers/iio/dac/ltc2688.c

LTC2947 HARDWARE MONITOR DRIVER
M:	Nuno Sá <nuno.sa@analog.com>
L:	linux-hwmon@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/hwmon/adi,ltc2947.yaml
F:	drivers/hwmon/ltc2947-core.c
F:	drivers/hwmon/ltc2947-i2c.c
F:	drivers/hwmon/ltc2947-spi.c
F:	drivers/hwmon/ltc2947.h

LTC2983 IIO TEMPERATURE DRIVER
M:	Nuno Sá <nuno.sa@analog.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/iio/temperature/adi,ltc2983.yaml
F:	drivers/iio/temperature/ltc2983.c

LTC4261 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/ltc4261.rst
F:	drivers/hwmon/ltc4261.c

LTC4306 I2C MULTIPLEXER DRIVER
M:	Michael Hennerich <michael.hennerich@analog.com>
L:	linux-i2c@vger.kernel.org
S:	Supported
W:	https://ez.analog.com/linux-software-drivers
F:	Documentation/devicetree/bindings/i2c/i2c-mux-ltc4306.txt
F:	drivers/i2c/muxes/i2c-mux-ltc4306.c

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)
S:	Maintained
W:	http://linux-test-project.github.io/
T:	git git://github.com/linux-test-project/ltp.git

LYNX 28G SERDES PHY DRIVER
M:	Ioana Ciornei <ioana.ciornei@nxp.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/phy/fsl,lynx-28g.yaml
F:	drivers/phy/freescale/phy-fsl-lynx-28g.c

LYNX PCS MODULE
M:	Ioana Ciornei <ioana.ciornei@nxp.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/pcs/pcs-lynx.c
F:	include/linux/pcs-lynx.h

M68K ARCHITECTURE
M:	Geert Uytterhoeven <geert@linux-m68k.org>
L:	linux-m68k@lists.linux-m68k.org
S:	Maintained
W:	http://www.linux-m68k.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/geert/linux-m68k.git
F:	arch/m68k/
F:	drivers/zorro/

M68K ON APPLE MACINTOSH
M:	Joshua Thompson <funaho@jurai.org>
L:	linux-m68k@lists.linux-m68k.org
S:	Maintained
W:	http://www.mac.linux-m68k.org/
F:	arch/m68k/mac/
F:	drivers/macintosh/adb-iop.c
F:	drivers/macintosh/via-macii.c

M68K ON HP9000/300
M:	Philip Blundell <philb@gnu.org>
S:	Maintained
W:	http://www.tazenda.demon.co.uk/phil/linux-hp
F:	arch/m68k/hp300/

M88DS3103 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/m88ds3103*

M88RS2000 MEDIA DRIVER
M:	Malcolm Priestley <tvboxspy@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
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
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/radio/radio-ma901.c

MAC80211
M:	Johannes Berg <johannes@sipsolutions.net>
L:	linux-wireless@vger.kernel.org
S:	Maintained
W:	https://wireless.wiki.kernel.org/
Q:	https://patchwork.kernel.org/project/linux-wireless/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/wireless/wireless.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/wireless/wireless-next.git
F:	Documentation/networking/mac80211-injection.rst
F:	Documentation/networking/mac80211_hwsim/mac80211_hwsim.rst
F:	drivers/net/wireless/mac80211_hwsim.[ch]
F:	include/net/mac80211.h
F:	net/mac80211/

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
F:	include/dt-bindings/mailbox/
F:	Documentation/devicetree/bindings/mailbox/

MAILBOX ARM MHUv2
M:	Viresh Kumar <viresh.kumar@linaro.org>
M:	Tushar Khandelwal <Tushar.Khandelwal@arm.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/mailbox/arm_mhuv2.c
F:	include/linux/mailbox/arm_mhuv2_message.h
F:	Documentation/devicetree/bindings/mailbox/arm,mhuv2.yaml

MANAGEMENT COMPONENT TRANSPORT PROTOCOL (MCTP)
M:	Jeremy Kerr <jk@codeconstruct.com.au>
M:	Matt Johnston <matt@codeconstruct.com.au>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/networking/mctp.rst
F:	drivers/net/mctp/
F:	include/net/mctp.h
F:	include/net/mctpdevice.h
F:	include/net/netns/mctp.h
F:	net/mctp/

MAN-PAGES: MANUAL PAGES FOR LINUX -- Sections 2, 3, 4, 5, and 7
M:	Michael Kerrisk <mtk.manpages@gmail.com>
L:	linux-man@vger.kernel.org
S:	Maintained
W:	http://www.kernel.org/doc/man-pages

MARDUK (CREATOR CI40) DEVICE TREE SUPPORT
M:	Rahul Bedarkar <rahulbedarkar89@gmail.com>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	arch/mips/boot/dts/img/pistachio*

MARVELL 88E6XXX ETHERNET SWITCH FABRIC DRIVER
M:	Andrew Lunn <andrew@lunn.ch>
M:	Vivien Didelot <vivien.didelot@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/dsa/marvell.txt
F:	Documentation/networking/devlink/mv88e6xxx.rst
F:	drivers/net/dsa/mv88e6xxx/
F:	include/linux/dsa/mv88e6xxx.h
F:	include/linux/platform_data/mv88e6xxx.h

MARVELL ARMADA 3700 PHY DRIVERS
M:	Miquel Raynal <miquel.raynal@bootlin.com>
S:	Maintained
F:	Documentation/devicetree/bindings/phy/phy-mvebu-comphy.txt
F:	Documentation/devicetree/bindings/phy/marvell,armada-3700-utmi-phy.yaml
F:	drivers/phy/marvell/phy-mvebu-a3700-comphy.c
F:	drivers/phy/marvell/phy-mvebu-a3700-utmi.c

MARVELL ARMADA 3700 SERIAL DRIVER
M:	Pali Rohár <pali@kernel.org>
S:	Maintained
F:	Documentation/devicetree/bindings/clock/marvell,armada-3700-uart-clock.yaml
F:	Documentation/devicetree/bindings/serial/mvebu-uart.txt
F:	drivers/tty/serial/mvebu-uart.c

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:	Documentation/devicetree/bindings/display/armada/
F:	drivers/gpu/drm/armada/
F:	include/uapi/drm/armada_drm.h

MARVELL CRYPTO DRIVER
M:	Boris Brezillon <bbrezillon@kernel.org>
M:	Arnaud Ebalard <arno@natisbad.org>
M:	Srujana Challa <schalla@marvell.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/marvell/
F:	include/linux/soc/marvell/octeontx2/

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 (moderated for non-subscribers)
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>
M:	Marek Behún <kabel@kernel.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/phy/marvell10g.c

MARVELL MVEBU THERMAL DRIVER
M:	Miquel Raynal <miquel.raynal@bootlin.com>
S:	Maintained
F:	drivers/thermal/armada_thermal.c

MARVELL MVNETA ETHERNET DRIVER
M:	Thomas Petazzoni <thomas.petazzoni@bootlin.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/marvell/mvneta.*

MARVELL MVPP2 ETHERNET DRIVER
M:	Marcin Wojtas <mw@semihalf.com>
M:	Russell King <linux@armlinux.org.uk>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/marvell-pp2.txt
F:	drivers/net/ethernet/marvell/mvpp2/

MARVELL MWIFIEX WIRELESS DRIVER
M:	Amitkumar Karwar <amitkarwar@gmail.com>
M:	Ganapathi Bhat <ganapathi017@gmail.com>
M:	Sharvari Harisangam <sharvari.harisangam@nxp.com>
M:	Xinming Hu <huxinming820@gmail.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:	Documentation/devicetree/bindings/mtd/marvell-nand.txt
F:	drivers/mtd/nand/raw/marvell_nand.c

MARVELL OCTEONTX2 PHYSICAL FUNCTION DRIVER
M:	Sunil Goutham <sgoutham@marvell.com>
M:	Geetha sowjanya <gakula@marvell.com>
M:	Subbaraya Sundeep <sbhatta@marvell.com>
M:	hariprasad <hkelam@marvell.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/marvell/octeontx2/nic/
F:	include/linux/soc/marvell/octeontx2/

MARVELL OCTEONTX2 RVU ADMIN FUNCTION DRIVER
M:	Sunil Goutham <sgoutham@marvell.com>
M:	Linu Cherian <lcherian@marvell.com>
M:	Geetha sowjanya <gakula@marvell.com>
M:	Jerin Jacob <jerinj@marvell.com>
M:	hariprasad <hkelam@marvell.com>
M:	Subbaraya Sundeep <sbhatta@marvell.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/device_drivers/ethernet/marvell/octeontx2.rst
F:	drivers/net/ethernet/marvell/octeontx2/af/

MARVELL PRESTERA ETHERNET SWITCH DRIVER
M:	Taras Chornyi <tchornyi@marvell.com>
S:	Supported
W:	https://github.com/Marvell-switching/switchdev-prestera
F:	drivers/net/ethernet/marvell/prestera/

MARVELL SOC MMC/SD/SDIO CONTROLLER DRIVER
M:	Nicolas Pitre <nico@fluxnic.net>
S:	Odd Fixes
F:	drivers/mmc/host/mvsdio.*

MARVELL USB MDIO CONTROLLER DRIVER
M:	Tobias Waldekranz <tobias@waldekranz.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/marvell,mvusb.yaml
F:	drivers/net/mdio/mdio-mvusb.c

MARVELL XENON MMC/SD/SDIO HOST CONTROLLER DRIVER
M:	Hu Ziji <huziji@marvell.com>
L:	linux-mmc@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/mmc/marvell,xenon-sdhci.yaml
F:	drivers/mmc/host/sdhci-xenon*

MARVELL OCTEON ENDPOINT DRIVER
M:	Veerasenareddy Burru <vburru@marvell.com>
M:	Abhijit Ayarekar <aayarekar@marvell.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/marvell/octeon_ep

MATROX FRAMEBUFFER DRIVER
L:	linux-fbdev@vger.kernel.org
S:	Orphan
F:	drivers/video/fbdev/matrox/matroxfb_*
F:	include/uapi/linux/matroxfb.h

MAX15301 DRIVER
M:	Daniel Nilsson <daniel.nilsson@flex.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/max15301.rst
F:	drivers/hwmon/pmbus/max15301.c

MAX16065 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/max16065.rst
F:	drivers/hwmon/max16065.c

MAX2175 SDR TUNER DRIVER
M:	Ramesh Shanmugasundaram <rashanmu@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/max2175.txt
F:	Documentation/userspace-api/media/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.rst
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/devicetree/bindings/hwmon/max6697.txt
F:	Documentation/hwmon/max6697.rst
F:	drivers/hwmon/max6697.c
F:	include/linux/platform_data/max6697.h

MAX9286 QUAD GMSL DESERIALIZER DRIVER
M:	Jacopo Mondi <jacopo+renesas@jmondi.org>
M:	Kieran Bingham <kieran.bingham+renesas@ideasonboard.com>
M:	Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com>
M:	Niklas Söderlund <niklas.soderlund+renesas@ragnatech.se>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/i2c/maxim,max9286.yaml
F:	drivers/media/i2c/max9286.c

MAX96712 QUAD GMSL2 DESERIALIZER DRIVER
M:	Niklas Söderlund <niklas.soderlund@ragnatech.se>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/staging/media/max96712/max96712.c

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.*

MAXBOTIX ULTRASONIC RANGER IIO DRIVER
M:	Andreas Klinger <ak@it-klinger.de>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/proximity/maxbotix,mb1232.yaml
F:	drivers/iio/proximity/mb1232.c

MAXIM MAX17040 FAMILY FUEL GAUGE DRIVERS
R:	Iskren Chernev <iskren.chernev@gmail.com>
R:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
R:	Marek Szyprowski <m.szyprowski@samsung.com>
R:	Matheus Castello <matheus@castello.eng.br>
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/power/supply/maxim,max17040.yaml
F:	drivers/power/supply/max17040_battery.c

MAXIM MAX17042 FAMILY FUEL GAUGE DRIVERS
R:	Hans de Goede <hdegoede@redhat.com>
R:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
R:	Marek Szyprowski <m.szyprowski@samsung.com>
R:	Sebastian Krzyszkowiak <sebastian.krzyszkowiak@puri.sm>
R:	Purism Kernel Team <kernel@puri.sm>
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/power/supply/maxim,max17042.yaml
F:	drivers/power/supply/max17042_battery.c

MAXIM MAX20086 CAMERA POWER PROTECTOR DRIVER
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/regulator/maxim,max20086.yaml
F:	drivers/regulator/max20086-regulator.c

MAXIM MAX77650 PMIC MFD DRIVER
M:	Bartosz Golaszewski <brgl@bgdev.pl>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/*/*max77650.yaml
F:	Documentation/devicetree/bindings/*/max77650*.yaml
F:	drivers/gpio/gpio-max77650.c
F:	drivers/input/misc/max77650-onkey.c
F:	drivers/leds/leds-max77650.c
F:	drivers/mfd/max77650.c
F:	drivers/power/supply/max77650-charger.c
F:	drivers/regulator/max77650-regulator.c
F:	include/linux/mfd/max77650.h

MAXIM MAX77714 PMIC MFD DRIVER
M:	Luca Ceresoli <luca@lucaceresoli.net>
S:	Maintained
F:	Documentation/devicetree/bindings/mfd/maxim,max77714.yaml
F:	drivers/mfd/max77714.c
F:	include/linux/mfd/max77714.h

MAXIM MAX77802 PMIC REGULATOR DEVICE DRIVER
M:	Javier Martinez Canillas <javier@dowhile0.org>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/*/*max77802.yaml
F:	drivers/regulator/max77802-regulator.c
F:	include/dt-bindings/*/*max77802.h

MAXIM MAX77976 BATTERY CHARGER
M:	Luca Ceresoli <luca@lucaceresoli.net>
S:	Supported
F:	Documentation/devicetree/bindings/power/supply/maxim,max77976.yaml
F:	drivers/power/supply/max77976_charger.c

MAXIM MUIC CHARGER DRIVERS FOR EXYNOS BASED BOARDS
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
L:	linux-pm@vger.kernel.org
S:	Supported
B:	mailto:linux-samsung-soc@vger.kernel.org
F:	Documentation/devicetree/bindings/power/supply/maxim,max14577.yaml
F:	Documentation/devicetree/bindings/power/supply/maxim,max77693.yaml
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 <krzysztof.kozlowski@linaro.org>
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
B:	mailto:linux-samsung-soc@vger.kernel.org
F:	Documentation/devicetree/bindings/*/maxim,max14577.yaml
F:	Documentation/devicetree/bindings/*/maxim,max77686.yaml
F:	Documentation/devicetree/bindings/*/maxim,max77693.yaml
F:	Documentation/devicetree/bindings/*/maxim,max77843.yaml
F:	Documentation/devicetree/bindings/clock/maxim,max77686.txt
F:	Documentation/devicetree/bindings/mfd/max77693.txt
F:	drivers/*/*max77843.c
F:	drivers/*/max14577*.c
F:	drivers/*/max77686*.c
F:	drivers/*/max77693*.c
F:	drivers/clk/clk-max77686.c
F:	drivers/extcon/extcon-max14577.c
F:	drivers/extcon/extcon-max77693.c
F:	drivers/rtc/rtc-max77686.c
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
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/radio/radio-maxiradio*

MAXLINEAR ETHERNET PHY DRIVER
M:	Xu Liang <lxu@maxlinear.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/phy/mxl-gpy.c

MCBA MICROCHIP CAN BUS ANALYZER TOOL DRIVER
R:	Yasushi SHOJI <yashi@spacecubics.com>
L:	linux-can@vger.kernel.org
S:	Maintained
F:	drivers/net/can/usb/mcba_usb.c

MCAN MMIO DEVICE DRIVER
M:	Chandrasekar Ramakrishnan <rcsekar@samsung.com>
L:	linux-can@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/can/bosch,m_can.yaml
F:	drivers/net/can/m_can/m_can.c
F:	drivers/net/can/m_can/m_can.h
F:	drivers/net/can/m_can/m_can_platform.c

MCP2221A MICROCHIP USB-HID TO I2C BRIDGE DRIVER
M:	Rishi Gupta <gupt21@gmail.com>
L:	linux-i2c@vger.kernel.org
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/hid-mcp2221.c

MCP251XFD SPI-CAN NETWORK DRIVER
M:	Marc Kleine-Budde <mkl@pengutronix.de>
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
R:	Thomas Kopp <thomas.kopp@microchip.com>
L:	linux-can@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/can/microchip,mcp251xfd.yaml
F:	drivers/net/can/spi/mcp251xfd/

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
S:	Maintained
W:	https://github.com/xueliu/mcr20a-linux
F:	Documentation/devicetree/bindings/net/ieee802154/mcr20a.txt
F:	drivers/net/ieee802154/mcr20a.c
F:	drivers/net/ieee802154/mcr20a.h

MEASUREMENT COMPUTING CIO-DAC IIO DRIVER
M:	William Breathitt Gray <william.gray@linaro.org>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	drivers/iio/dac/cio-dac.c

MEDIA CONTROLLER FRAMEWORK
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
S:	Supported
W:	https://www.linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/mc/
F:	include/media/media-*.h
F:	include/uapi/linux/media.h

MEDIA DRIVER FOR FREESCALE IMX PXP
M:	Philipp Zabel <p.zabel@pengutronix.de>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/platform/nxp/imx-pxp.[ch]

MEDIA DRIVERS FOR ASCOT2E
M:	Sergey Kozlov <serjk@netup.ru>
M:	Abylay Ospan <aospan@netup.ru>
L:	linux-media@vger.kernel.org
S:	Supported
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/dvb-frontends/ascot2e*

MEDIA DRIVERS FOR CXD2099AR CI CONTROLLERS
M:	Jasmin Jessich <jasmin@anw.at>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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
S:	Supported
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/dvb-frontends/cxd2841er*

MEDIA DRIVERS FOR CXD2880
M:	Yasunari Takiguchi <Yasunari.Takiguchi@sony.com>
L:	linux-media@vger.kernel.org
S:	Supported
W:	http://linuxtv.org/
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/dvb-frontends/cxd2880/*
F:	drivers/media/spi/cxd2880*

MEDIA DRIVERS FOR DIGITAL DEVICES PCIE DEVICES
L:	linux-media@vger.kernel.org
S:	Orphan
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/admin-guide/media/imx.rst
F:	Documentation/devicetree/bindings/media/imx.txt
F:	drivers/staging/media/imx/
F:	include/linux/imx-media.h
F:	include/media/imx.h

MEDIA DRIVERS FOR FREESCALE IMX7
M:	Rui Miguel Silva <rmfrfs@gmail.com>
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/admin-guide/media/imx7.rst
F:	Documentation/devicetree/bindings/media/nxp,imx-mipi-csi2.yaml
F:	Documentation/devicetree/bindings/media/nxp,imx7-csi.yaml
F:	drivers/media/platform/nxp/imx-mipi-csis.c
F:	drivers/staging/media/imx/imx7-media-csi.c

MEDIA DRIVERS FOR HELENE
M:	Abylay Ospan <aospan@netup.ru>
L:	linux-media@vger.kernel.org
S:	Supported
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
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
S:	Supported
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
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
S:	Supported
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/dvb-frontends/lnbh25*

MEDIA DRIVERS FOR MXL5XX TUNER DEMODULATORS
L:	linux-media@vger.kernel.org
S:	Orphan
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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
S:	Supported
W:	https://linuxtv.org
W:	http://netup.tv/
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/pci/netup_unidvb/*

MEDIA DRIVERS FOR NVIDIA TEGRA - VDE
M:	Dmitry Osipenko <digetx@gmail.com>
L:	linux-media@vger.kernel.org
L:	linux-tegra@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/nvidia,tegra-vde.yaml
F:	drivers/media/platform/nvidia/tegra-vde/

MEDIA DRIVERS FOR RENESAS - CEU
M:	Jacopo Mondi <jacopo@jmondi.org>
L:	linux-media@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/renesas,ceu.yaml
F:	drivers/media/platform/renesas/renesas-ceu.c
F:	include/media/drv-intf/renesas-ceu.h

MEDIA DRIVERS FOR RENESAS - DRIF
M:	Fabrizio Castro <fabrizio.castro.jz@renesas.com>
L:	linux-media@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/renesas,drif.yaml
F:	drivers/media/platform/renesas/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
S:	Supported
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/renesas,fcp.yaml
F:	drivers/media/platform/renesas/rcar-fcp.c
F:	include/media/rcar-fcp.h

MEDIA DRIVERS FOR RENESAS - FDP1
M:	Kieran Bingham <kieran.bingham+renesas@ideasonboard.com>
L:	linux-media@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/renesas,fdp1.yaml
F:	drivers/media/platform/renesas/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
S:	Supported
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/renesas,csi2.yaml
F:	Documentation/devicetree/bindings/media/renesas,isp.yaml
F:	Documentation/devicetree/bindings/media/renesas,vin.yaml
F:	drivers/media/platform/renesas/rcar-isp.c
F:	drivers/media/platform/renesas/rcar-vin/

MEDIA DRIVERS FOR RENESAS - VSP1
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
M:	Kieran Bingham <kieran.bingham+renesas@ideasonboard.com>
L:	linux-media@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/renesas,vsp1.yaml
F:	drivers/media/platform/renesas/vsp1/

MEDIA DRIVERS FOR ST STV0910 DEMODULATOR ICs
L:	linux-media@vger.kernel.org
S:	Orphan
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/dvb-frontends/stv0910*

MEDIA DRIVERS FOR ST STV6111 TUNER ICs
L:	linux-media@vger.kernel.org
S:	Orphan
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/dvb-frontends/stv6111*

MEDIA DRIVERS FOR STM32 - DCMI
M:	Hugues Fruchet <hugues.fruchet@foss.st.com>
L:	linux-media@vger.kernel.org
S:	Supported
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/st,stm32-dcmi.yaml
F:	drivers/media/platform/st/stm32/stm32-dcmi.c

MEDIA INPUT INFRASTRUCTURE (V4L/DVB)
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.kernel.org/project/linux-media/list/
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/admin-guide/media/
F:	Documentation/devicetree/bindings/media/
F:	Documentation/driver-api/media/
F:	Documentation/userspace-api/media/
F:	drivers/media/
F:	drivers/staging/media/
F:	include/dt-bindings/media/
F:	include/linux/platform_data/media/
F:	include/media/
F:	include/uapi/linux/dvb/
F:	include/uapi/linux/ivtv*
F:	include/uapi/linux/media.h
F:	include/uapi/linux/meye.h
F:	include/uapi/linux/uvcvideo.h
F:	include/uapi/linux/v4l2-*
F:	include/uapi/linux/videodev2.h

MEDIATEK BLUETOOTH DRIVER
M:	Sean Wang <sean.wang@mediatek.com>
L:	linux-bluetooth@vger.kernel.org
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/net/mediatek-bluetooth.txt
F:	drivers/bluetooth/btmtkuart.c

MEDIATEK BOARD LEVEL SHUTDOWN DRIVERS
M:	Sean Wang <sean.wang@mediatek.com>
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/power/reset/mt6323-poweroff.txt
F:	drivers/power/reset/mt6323-poweroff.c

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 ETHERNET DRIVER
M:	Felix Fietkau <nbd@nbd.name>
M:	John Crispin <john@phrozen.org>
M:	Sean Wang <sean.wang@mediatek.com>
M:	Mark Lee <Mark-MC.Lee@mediatek.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/mediatek/

MEDIATEK I2C CONTROLLER DRIVER
M:	Qii Wang <qii.wang@mediatek.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-mt65xx.yaml
F:	drivers/i2c/busses/i2c-mt65xx.c

MEDIATEK IOMMU DRIVER
M:	Yong Wu <yong.wu@mediatek.com>
L:	iommu@lists.linux.dev
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/iommu/mediatek*
F:	drivers/iommu/mtk_iommu*
F:	include/dt-bindings/memory/mt*-port.h

MEDIATEK JPEG DRIVER
M:	Bin Liu <bin.liu@mediatek.com>
S:	Supported
F:	Documentation/devicetree/bindings/media/mediatek-jpeg-*.yaml
F:	drivers/media/platform/mediatek/jpeg/

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:	Documentation/devicetree/bindings/media/mediatek-mdp.txt
F:	drivers/media/platform/mediatek/mdp/
F:	drivers/media/platform/mediatek/vpu/

MEDIATEK MEDIA DRIVER
M:	Tiffany Lin <tiffany.lin@mediatek.com>
M:	Andrew-CT Chen <andrew-ct.chen@mediatek.com>
M:	Yunfei Dong <yunfei.dong@mediatek.com>
S:	Supported
F:	Documentation/devicetree/bindings/media/mediatek,vcodec*.yaml
F:	Documentation/devicetree/bindings/media/mediatek-vpu.txt
F:	drivers/media/platform/mediatek/vcodec/
F:	drivers/media/platform/mediatek/vpu/

MEDIATEK MMC/SD/SDIO DRIVER
M:	Chaotian Jing <chaotian.jing@mediatek.com>
S:	Maintained
F:	Documentation/devicetree/bindings/mmc/mtk-sd.yaml
F:	drivers/mmc/host/mtk-sd.c

MEDIATEK MT76 WIRELESS LAN DRIVER
M:	Felix Fietkau <nbd@nbd.name>
M:	Lorenzo Bianconi <lorenzo@kernel.org>
M:	Ryder Lee <ryder.lee@mediatek.com>
R:	Shayne Chen <shayne.chen@mediatek.com>
R:	Sean Wang <sean.wang@mediatek.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/wireless/mediatek,mt76.yaml
F:	drivers/net/wireless/mediatek/mt76/

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 MT7621 CLOCK DRIVER
M:	Sergio Paracuellos <sergio.paracuellos@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/clock/mediatek,mt7621-sysc.yaml
F:	drivers/clk/ralink/clk-mt7621.c

MEDIATEK MT7621/28/88 I2C DRIVER
M:	Stefan Roese <sr@denx.de>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-mt7621.txt
F:	drivers/i2c/busses/i2c-mt7621.c

MEDIATEK MT7621 PCIE CONTROLLER DRIVER
M:	Sergio Paracuellos <sergio.paracuellos@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/pci/mediatek,mt7621-pcie.yaml
F:	drivers/pci/controller/pcie-mt7621.c

MEDIATEK MT7621 PHY PCI DRIVER
M:	Sergio Paracuellos <sergio.paracuellos@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/phy/mediatek,mt7621-pci-phy.yaml
F:	drivers/phy/ralink/phy-mt7621-pci.c

MEDIATEK NAND CONTROLLER DRIVER
L:	linux-mtd@lists.infradead.org
S:	Orphan
F:	Documentation/devicetree/bindings/mtd/mtk-nand.txt
F:	drivers/mtd/nand/raw/mtk_*

MEDIATEK PMIC LED DRIVER
M:	Sean Wang <sean.wang@mediatek.com>
S:	Maintained
F:	Documentation/devicetree/bindings/leds/leds-mt6323.txt
F:	drivers/leds/leds-mt6323.c

MEDIATEK RANDOM NUMBER GENERATOR SUPPORT
M:	Sean Wang <sean.wang@mediatek.com>
S:	Maintained
F:	drivers/char/hw_random/mtk-rng.c

MEDIATEK SMI DRIVER
M:	Yong Wu <yong.wu@mediatek.com>
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/memory-controllers/mediatek,smi*
F:	drivers/memory/mtk-smi.c
F:	include/soc/mediatek/smi.h

MEDIATEK SWITCH DRIVER
M:	Sean Wang <sean.wang@mediatek.com>
M:	Landen Chao <Landen.Chao@mediatek.com>
M:	DENG Qingfang <dqfext@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/dsa/mt7530.*
F:	net/dsa/tag_mtk.c

MEDIATEK T7XX 5G WWAN MODEM DRIVER
M:	Chandrashekar Devegowda <chandrashekar.devegowda@intel.com>
M:	Intel Corporation <linuxwwan@intel.com>
R:	Chiranjeevi Rapolu <chiranjeevi.rapolu@linux.intel.com>
R:	Liu Haijun <haijun.liu@mediatek.com>
R:	M Chetan Kumar <m.chetan.kumar@linux.intel.com>
R:	Ricardo Martinez <ricardo.martinez@linux.intel.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/wwan/t7xx/

MEDIATEK USB3 DRD IP DRIVER
M:	Chunfeng Yun <chunfeng.yun@mediatek.com>
L:	linux-usb@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/usb/mediatek,*
F:	drivers/usb/host/xhci-mtk*
F:	drivers/usb/mtu3/

MEGACHIPS STDPXXXX-GE-B850V3-FW LVDS/DP++ BRIDGES
M:	Peter Senna Tschudin <peter.senna@gmail.com>
M:	Martin Donnelly <martin.donnelly@ge.com>
M:	Martyn Welch <martyn.welch@collabora.co.uk>
S:	Maintained
F:	Documentation/devicetree/bindings/display/bridge/megachips-stdpxxxx-ge-b850v3-fw.txt
F:	drivers/gpu/drm/bridge/megachips-stdpxxxx-ge-b850v3-fw.c

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
S:	Maintained
W:	http://www.avagotech.com/support/
F:	Documentation/scsi/megaraid.rst
F:	drivers/scsi/megaraid.*
F:	drivers/scsi/megaraid/

MELEXIS MLX90614 DRIVER
M:	Crt Mori <cmo@melexis.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	http://www.melexis.com
F:	drivers/iio/temperature/mlx90614.c

MELEXIS MLX90632 DRIVER
M:	Crt Mori <cmo@melexis.com>
L:	linux-iio@vger.kernel.org
S:	Supported
W:	http://www.melexis.com
F:	drivers/iio/temperature/mlx90632.c

MELFAS MIP4 TOUCHSCREEN DRIVER
M:	Sangwon Jee <jeesw@melfas.com>
S:	Supported
W:	http://www.melfas.com
F:	Documentation/devicetree/bindings/input/touchscreen/melfas_mip4.txt
F:	drivers/input/touchscreen/melfas_mip4.c

MELLANOX BLUEFIELD I2C DRIVER
M:	Khalil Blaiech <kblaiech@nvidia.com>
L:	linux-i2c@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/i2c/mellanox,i2c-mlxbf.yaml
F:	drivers/i2c/busses/i2c-mlxbf.c

MELLANOX ETHERNET DRIVER (mlx4_en)
M:	Tariq Toukan <tariqt@nvidia.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	https://patchwork.kernel.org/project/netdevbpf/list/
F:	drivers/net/ethernet/mellanox/mlx4/en_*

MELLANOX ETHERNET DRIVER (mlx5e)
M:	Saeed Mahameed <saeedm@nvidia.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	https://patchwork.kernel.org/project/netdevbpf/list/
F:	drivers/net/ethernet/mellanox/mlx5/core/en_*

MELLANOX ETHERNET INNOVA DRIVERS
R:	Boris Pismenny <borisp@nvidia.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	https://patchwork.kernel.org/project/netdevbpf/list/
F:	drivers/net/ethernet/mellanox/mlx5/core/en_accel/*
F:	drivers/net/ethernet/mellanox/mlx5/core/fpga/*
F:	include/linux/mlx5/mlx5_ifc_fpga.h

MELLANOX ETHERNET SWITCH DRIVERS
M:	Ido Schimmel <idosch@nvidia.com>
M:	Petr Machata <petrm@nvidia.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	https://patchwork.kernel.org/project/netdevbpf/list/
F:	drivers/net/ethernet/mellanox/mlxsw/
F:	tools/testing/selftests/drivers/net/mlxsw/

MELLANOX FIRMWARE FLASH LIBRARY (mlxfw)
M:	mlxsw@nvidia.com
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	https://patchwork.kernel.org/project/netdevbpf/list/
F:	drivers/net/ethernet/mellanox/mlxfw/

MELLANOX HARDWARE PLATFORM SUPPORT
M:	Hans de Goede <hdegoede@redhat.com>
M:	Mark Gross <markgross@kernel.org>
M:	Vadim Pasternak <vadimp@nvidia.com>
L:	platform-driver-x86@vger.kernel.org
S:	Supported
F:	Documentation/ABI/testing/sysfs-platform-mellanox-bootctl
F:	drivers/platform/mellanox/
F:	include/linux/platform_data/mlxreg.h

MELLANOX MLX4 core VPI driver
M:	Tariq Toukan <tariqt@nvidia.com>
L:	netdev@vger.kernel.org
L:	linux-rdma@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	https://patchwork.kernel.org/project/netdevbpf/list/
F:	drivers/net/ethernet/mellanox/mlx4/
F:	include/linux/mlx4/

MELLANOX MLX4 IB driver
M:	Yishai Hadas <yishaih@nvidia.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	http://patchwork.kernel.org/project/linux-rdma/list/
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@nvidia.com>
M:	Leon Romanovsky <leonro@nvidia.com>
L:	netdev@vger.kernel.org
L:	linux-rdma@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	https://patchwork.kernel.org/project/netdevbpf/list/
F:	Documentation/networking/device_drivers/ethernet/mellanox/
F:	drivers/net/ethernet/mellanox/mlx5/core/
F:	include/linux/mlx5/

MELLANOX MLX5 IB driver
M:	Leon Romanovsky <leonro@nvidia.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
W:	http://www.mellanox.com
Q:	http://patchwork.kernel.org/project/linux-rdma/list/
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@nvidia.com>
M:	Michael Shych <michaelsh@nvidia.com>
L:	linux-i2c@vger.kernel.org
S:	Supported
F:	Documentation/i2c/busses/i2c-mlxcpld.rst
F:	drivers/i2c/busses/i2c-mlxcpld.c
F:	drivers/i2c/muxes/i2c-mux-mlxcpld.c

MELLANOX MLXCPLD LED DRIVER
M:	Vadim Pasternak <vadimp@nvidia.com>
L:	linux-leds@vger.kernel.org
S:	Supported
F:	Documentation/leds/leds-mlxcpld.rst
F:	drivers/leds/leds-mlxcpld.c
F:	drivers/leds/leds-mlxreg.c

MELLANOX PLATFORM DRIVER
M:	Vadim Pasternak <vadimp@nvidia.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@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	arch/powerpc/include/asm/membarrier.h
F:	include/uapi/linux/membarrier.h
F:	kernel/sched/membarrier.c

MEMBLOCK
M:	Mike Rapoport <rppt@kernel.org>
L:	linux-mm@kvack.org
S:	Maintained
F:	Documentation/core-api/boot-time-mm.rst
F:	include/linux/memblock.h
F:	mm/memblock.c
F:	tools/testing/memblock/

MEMORY CONTROLLER DRIVERS
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
B:	mailto:krzysztof.kozlowski@linaro.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/krzk/linux-mem-ctrl.git
F:	Documentation/devicetree/bindings/memory-controllers/
F:	drivers/memory/
F:	include/dt-bindings/memory/
F:	include/memory/

MEMORY FREQUENCY SCALING DRIVERS FOR NVIDIA TEGRA
M:	Dmitry Osipenko <digetx@gmail.com>
L:	linux-pm@vger.kernel.org
L:	linux-tegra@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/linux.git
S:	Maintained
F:	drivers/devfreq/tegra30-devfreq.c

MEMORY MANAGEMENT
M:	Andrew Morton <akpm@linux-foundation.org>
L:	linux-mm@kvack.org
S:	Maintained
W:	http://www.linux-mm.org
T:	git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm
T:	quilt git://git.kernel.org/pub/scm/linux/kernel/git/akpm/25-new
F:	include/linux/gfp.h
F:	include/linux/memory_hotplug.h
F:	include/linux/mm.h
F:	include/linux/mmzone.h
F:	include/linux/pagewalk.h
F:	include/linux/vmalloc.h
F:	mm/
F:	tools/testing/selftests/vm/

MEMORY HOT(UN)PLUG
M:	David Hildenbrand <david@redhat.com>
M:	Oscar Salvador <osalvador@suse.de>
L:	linux-mm@kvack.org
S:	Maintained
F:	Documentation/admin-guide/mm/memory-hotplug.rst
F:	Documentation/core-api/memory-hotplug.rst
F:	drivers/base/memory.c
F:	include/linux/memory_hotplug.h
F:	mm/memory_hotplug.c
F:	tools/testing/selftests/memory-hotplug/

MEMORY TECHNOLOGY DEVICES (MTD)
M:	Miquel Raynal <miquel.raynal@bootlin.com>
M:	Richard Weinberger <richard@nod.at>
M:	Vignesh Raghavendra <vigneshr@ti.com>
L:	linux-mtd@lists.infradead.org
S:	Maintained
W:	http://www.linux-mtd.infradead.org/
Q:	http://patchwork.ozlabs.org/project/linux-mtd/list/
C:	irc://irc.oftc.net/mtd
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mtd/linux.git mtd/fixes
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mtd/linux.git mtd/next
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:	Documentation/driver-api/men-chameleon-bus.rst
F:	drivers/mcb/
F:	include/linux/mcb.h

MEN F21BMC (Board Management Controller)
M:	Andreas Werner <andreas.werner@men.de>
S:	Supported
F:	Documentation/hwmon/menf21bmc.rst
F:	drivers/hwmon/menf21bmc_hwmon.c
F:	drivers/leds/leds-menf21bmc.c
F:	drivers/mfd/menf21bmc.c
F:	drivers/watchdog/menf21bmc_wdt.c

MEN Z069 WATCHDOG DRIVER
M:	Johannes Thumshirn <jth@kernel.org>
L:	linux-watchdog@vger.kernel.org
S:	Maintained
F:	drivers/watchdog/menz69_wdt.c

MESON AO CEC DRIVER FOR AMLOGIC SOCS
M:	Neil Armstrong <narmstrong@baylibre.com>
L:	linux-media@vger.kernel.org
L:	linux-amlogic@lists.infradead.org
S:	Supported
W:	http://linux-meson.com/
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/amlogic,meson-gx-ao-cec.yaml
F:	drivers/media/cec/platform/meson/ao-cec-g12a.c
F:	drivers/media/cec/platform/meson/ao-cec.c

MESON GE2D DRIVER FOR AMLOGIC SOCS
M:	Neil Armstrong <narmstrong@baylibre.com>
L:	linux-media@vger.kernel.org
L:	linux-amlogic@lists.infradead.org
S:	Supported
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/amlogic,axg-ge2d.yaml
F:	drivers/media/platform/amlogic/meson-ge2d/

MESON NAND CONTROLLER DRIVER FOR AMLOGIC SOCS
M:	Liang Yang <liang.yang@amlogic.com>
L:	linux-mtd@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/mtd/amlogic,meson-nand.txt
F:	drivers/mtd/nand/raw/meson_*

MESON VIDEO DECODER DRIVER FOR AMLOGIC SOCS
M:	Neil Armstrong <narmstrong@baylibre.com>
L:	linux-media@vger.kernel.org
L:	linux-amlogic@lists.infradead.org
S:	Supported
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/amlogic,gx-vdec.yaml
F:	drivers/staging/media/meson/vdec/

METHODE UDPU SUPPORT
M:	Vladimir Vid <vladimir.vid@sartura.hr>
S:	Maintained
F:	arch/arm64/boot/dts/marvell/armada-3720-uDPU.dts

MHI BUS
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
R:	Hemant Kumar <quic_hemantk@quicinc.com>
L:	mhi@lists.linux.dev
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mani/mhi.git
F:	Documentation/ABI/stable/sysfs-bus-mhi
F:	Documentation/mhi/
F:	drivers/bus/mhi/
F:	include/linux/mhi.h

MICROBLAZE ARCHITECTURE
M:	Michal Simek <monstr@monstr.eu>
S:	Supported
W:	http://www.monstr.eu/fdt/
T:	git git://git.monstr.eu/linux-2.6-microblaze.git
F:	arch/microblaze/

MICROCHIP AT91 DMA DRIVERS
M:	Ludovic Desroches <ludovic.desroches@microchip.com>
M:	Tudor Ambarus <tudor.ambarus@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	dmaengine@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/dma/atmel-dma.txt
F:	drivers/dma/at_hdmac.c
F:	drivers/dma/at_hdmac_regs.h
F:	drivers/dma/at_xdmac.c
F:	include/dt-bindings/dma/at91.h

MICROCHIP AT91 SERIAL DRIVER
M:	Richard Genoud <richard.genoud@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/mfd/atmel-usart.txt
F:	drivers/tty/serial/atmel_serial.c
F:	drivers/tty/serial/atmel_serial.h

MICROCHIP AT91 USART MFD DRIVER
M:	Radu Pirea <radu_nicolae.pirea@upb.ro>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/mfd/atmel-usart.txt
F:	drivers/mfd/at91-usart.c
F:	include/dt-bindings/mfd/at91-usart.h

MICROCHIP AT91 USART SPI DRIVER
M:	Radu Pirea <radu_nicolae.pirea@upb.ro>
L:	linux-spi@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/mfd/atmel-usart.txt
F:	drivers/spi/spi-at91-usart.c

MICROCHIP AUDIO ASOC DRIVERS
M:	Codrin Ciubotariu <codrin.ciubotariu@microchip.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
F:	sound/soc/atmel

MICROCHIP CSI2DC DRIVER
M:	Eugen Hristev <eugen.hristev@microchip.com>
L:	linux-media@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/media/microchip,csi2dc.yaml
F:	drivers/media/platform/atmel/microchip-csi2dc.c

MICROCHIP ECC DRIVER
M:	Tudor Ambarus <tudor.ambarus@microchip.com>
L:	linux-crypto@vger.kernel.org
S:	Maintained
F:	drivers/crypto/atmel-ecc.*

MICROCHIP EIC DRIVER
M:	Claudiu Beznea <claudiu.beznea@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	drivers/irqchip/irq-mchp-eic.c

MICROCHIP I2C DRIVER
M:	Codrin Ciubotariu <codrin.ciubotariu@microchip.com>
L:	linux-i2c@vger.kernel.org
S:	Supported
F:	drivers/i2c/busses/i2c-at91-*.c
F:	drivers/i2c/busses/i2c-at91.h

MICROCHIP ISC DRIVER
M:	Eugen Hristev <eugen.hristev@microchip.com>
L:	linux-media@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/media/atmel,isc.yaml
F:	Documentation/devicetree/bindings/media/microchip,xisc.yaml
F:	drivers/media/platform/atmel/atmel-isc*
F:	drivers/media/platform/atmel/atmel-sama*-isc*
F:	include/linux/atmel-isc-media.h

MICROCHIP ISI DRIVER
M:	Eugen Hristev <eugen.hristev@microchip.com>
L:	linux-media@vger.kernel.org
S:	Supported
F:	drivers/media/platform/atmel/atmel-isi.c
F:	drivers/media/platform/atmel/atmel-isi.h

MICROCHIP KSZ SERIES ETHERNET SWITCH DRIVER
M:	Woojung Huh <woojung.huh@microchip.com>
M:	UNGLinuxDriver@microchip.com
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/dsa/microchip,ksz.yaml
F:	Documentation/devicetree/bindings/net/dsa/microchip,lan937x.yaml
F:	drivers/net/dsa/microchip/*
F:	include/linux/platform_data/microchip-ksz.h
F:	net/dsa/tag_ksz.c

MICROCHIP LAN87xx/LAN937x T1 PHY DRIVER
M:	Arun Ramadoss <arun.ramadoss@microchip.com>
R:	UNGLinuxDriver@microchip.com
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/phy/microchip_t1.c

MICROCHIP LAN743X ETHERNET DRIVER
M:	Bryan Whitehead <bryan.whitehead@microchip.com>
M:	UNGLinuxDriver@microchip.com
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/microchip/lan743x_*

MICROCHIP LAN966X ETHERNET DRIVER
M:	Horatiu Vultur <horatiu.vultur@microchip.com>
M:	UNGLinuxDriver@microchip.com
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/microchip/lan966x/*

MICROCHIP 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

MICROCHIP MCP16502 PMIC DRIVER
M:	Claudiu Beznea <claudiu.beznea@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/regulator/mcp16502-regulator.txt
F:	drivers/regulator/mcp16502.c

MICROCHIP MCP3911 ADC DRIVER
M:	Marcus Folkesson <marcus.folkesson@gmail.com>
M:	Kent Gustavsson <kent@minoris.se>
L:	linux-iio@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/iio/adc/microchip,mcp3911.yaml
F:	drivers/iio/adc/mcp3911.c

MICROCHIP MMC/SD/SDIO MCI DRIVER
M:	Ludovic Desroches <ludovic.desroches@microchip.com>
S:	Maintained
F:	drivers/mmc/host/atmel-mci.c

MICROCHIP NAND DRIVER
M:	Tudor Ambarus <tudor.ambarus@microchip.com>
L:	linux-mtd@lists.infradead.org
S:	Supported
F:	Documentation/devicetree/bindings/mtd/atmel-nand.txt
F:	drivers/mtd/nand/raw/atmel/*

MICROCHIP OTPC DRIVER
M:	Claudiu Beznea <claudiu.beznea@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/nvmem/microchip,sama7g5-otpc.yaml
F:	drivers/nvmem/microchip-otpc.c
F:	include/dt-bindings/nvmem/microchip,sama7g5-otpc.h

MICROCHIP PWM DRIVER
M:	Claudiu Beznea <claudiu.beznea@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-pwm@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/pwm/atmel,at91sam-pwm.yaml
F:	drivers/pwm/pwm-atmel.c

MICROCHIP SAMA5D2-COMPATIBLE ADC DRIVER
M:	Eugen Hristev <eugen.hristev@microchip.com>
L:	linux-iio@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/iio/adc/atmel,sama5d2-adc.yaml
F:	drivers/iio/adc/at91-sama5d2_adc.c
F:	include/dt-bindings/iio/adc/at91-sama5d2_adc.h

MICROCHIP SAMA5D2-COMPATIBLE SHUTDOWN CONTROLLER
M:	Claudiu Beznea <claudiu.beznea@microchip.com>
S:	Supported
F:	drivers/power/reset/at91-sama5d2_shdwc.c

MICROCHIP SPI DRIVER
M:	Tudor Ambarus <tudor.ambarus@microchip.com>
S:	Supported
F:	drivers/spi/spi-atmel.*

MICROCHIP SSC DRIVER
M:	Codrin Ciubotariu <codrin.ciubotariu@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

MICROCHIP USB251XB DRIVER
M:	Richard Leitner <richard.leitner@skidata.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/usb/usb251xb.txt
F:	drivers/usb/misc/usb251xb.c

MICROCHIP USBA UDC DRIVER
M:	Cristian Birsan <cristian.birsan@microchip.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	drivers/usb/gadget/udc/atmel_usba_udc.*

MICROCHIP WILC1000 WIFI DRIVER
M:	Ajay Singh <ajay.kathat@microchip.com>
M:	Claudiu Beznea <claudiu.beznea@microchip.com>
L:	linux-wireless@vger.kernel.org
S:	Supported
F:	drivers/net/wireless/microchip/wilc1000/

MICROSEMI MIPS SOCS
M:	Alexandre Belloni <alexandre.belloni@bootlin.com>
M:	UNGLinuxDriver@microchip.com
L:	linux-mips@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/mips/mscc.txt
F:	Documentation/devicetree/bindings/power/reset/ocelot-reset.txt
F:	arch/mips/boot/dts/mscc/
F:	arch/mips/configs/generic/board-ocelot.config
F:	arch/mips/generic/board-ocelot.c

MICROSEMI SMART ARRAY SMARTPQI DRIVER (smartpqi)
M:	Don Brace <don.brace@microchip.com>
L:	storagedev@microchip.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	Documentation/scsi/smartpqi.rst
F:	drivers/scsi/smartpqi/Kconfig
F:	drivers/scsi/smartpqi/Makefile
F:	drivers/scsi/smartpqi/smartpqi*.[ch]
F:	include/linux/cciss*.h
F:	include/uapi/linux/cciss*.h

MICROSOFT SURFACE AGGREGATOR TABLET-MODE SWITCH
M:	Maximilian Luz <luzmaximilian@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/surface/surface_aggregator_tabletsw.c

MICROSOFT SURFACE BATTERY AND AC DRIVERS
M:	Maximilian Luz <luzmaximilian@gmail.com>
L:	linux-pm@vger.kernel.org
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/power/supply/surface_battery.c
F:	drivers/power/supply/surface_charger.c

MICROSOFT SURFACE DTX DRIVER
M:	Maximilian Luz <luzmaximilian@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	Documentation/driver-api/surface_aggregator/clients/dtx.rst
F:	drivers/platform/surface/surface_dtx.c
F:	include/uapi/linux/surface_aggregator/dtx.h

MICROSOFT SURFACE GPE LID SUPPORT DRIVER
M:	Maximilian Luz <luzmaximilian@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/surface/surface_gpe.c

MICROSOFT SURFACE HARDWARE PLATFORM SUPPORT
M:	Hans de Goede <hdegoede@redhat.com>
M:	Mark Gross <markgross@kernel.org>
M:	Maximilian Luz <luzmaximilian@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pdx86/platform-drivers-x86.git
F:	drivers/platform/surface/

MICROSOFT SURFACE HID TRANSPORT DRIVER
M:	Maximilian Luz <luzmaximilian@gmail.com>
L:	linux-input@vger.kernel.org
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/hid/surface-hid/

MICROSOFT SURFACE HOT-PLUG DRIVER
M:	Maximilian Luz <luzmaximilian@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/surface/surface_hotplug.c

MICROSOFT SURFACE PLATFORM PROFILE DRIVER
M:	Maximilian Luz <luzmaximilian@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/surface/surface_platform_profile.c

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/surface/surfacepro3_button.c

MICROSOFT SURFACE SYSTEM AGGREGATOR SUBSYSTEM
M:	Maximilian Luz <luzmaximilian@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
W:	https://github.com/linux-surface/surface-aggregator-module
C:	irc://irc.libera.chat/linux-surface
F:	Documentation/driver-api/surface_aggregator/
F:	drivers/platform/surface/aggregator/
F:	drivers/platform/surface/surface_acpi_notify.c
F:	drivers/platform/surface/surface_aggregator_cdev.c
F:	drivers/platform/surface/surface_aggregator_registry.c
F:	include/linux/surface_acpi_notify.h
F:	include/linux/surface_aggregator/
F:	include/uapi/linux/surface_aggregator/

MICROSOFT SURFACE SYSTEM AGGREGATOR HUB DRIVER
M:	Maximilian Luz <luzmaximilian@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/surface/surface_aggregator_hub.c

MICROTEK X6 SCANNER
M:	Oliver Neukum <oliver@neukum.org>
S:	Maintained
F:	drivers/usb/image/microtek.*

MIKROTIK CRS3XX 98DX3236 BOARD SUPPORT
M:	Luka Kovacic <luka.kovacic@sartura.hr>
M:	Luka Perkov <luka.perkov@sartura.hr>
S:	Maintained
F:	arch/arm/boot/dts/armada-xp-crs305-1g-4s-bit.dts
F:	arch/arm/boot/dts/armada-xp-crs305-1g-4s.dts
F:	arch/arm/boot/dts/armada-xp-crs326-24g-2s-bit.dts
F:	arch/arm/boot/dts/armada-xp-crs326-24g-2s.dts
F:	arch/arm/boot/dts/armada-xp-crs328-4c-20s-4s-bit.dts
F:	arch/arm/boot/dts/armada-xp-crs328-4c-20s-4s.dts

MIPI CCS, SMIA AND SMIA++ IMAGE SENSOR DRIVER
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/i2c/mipi-ccs.yaml
F:	Documentation/driver-api/media/drivers/ccs/
F:	Documentation/userspace-api/media/drivers/ccs.rst
F:	drivers/media/i2c/ccs-pll.c
F:	drivers/media/i2c/ccs-pll.h
F:	drivers/media/i2c/ccs/
F:	include/uapi/linux/ccs.h
F:	include/uapi/linux/smiapp.h

MIPS
M:	Thomas Bogendoerfer <tsbogend@alpha.franken.de>
L:	linux-mips@vger.kernel.org
S:	Maintained
W:	http://www.linux-mips.org/
Q:	https://patchwork.kernel.org/project/linux-mips/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mips/linux.git
F:	Documentation/devicetree/bindings/mips/
F:	Documentation/mips/
F:	arch/mips/
F:	drivers/platform/mips/

MIPS BOSTON DEVELOPMENT BOARD
M:	Paul Burton <paulburton@kernel.org>
L:	linux-mips@vger.kernel.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 CORE DRIVERS
M:	Thomas Bogendoerfer <tsbogend@alpha.franken.de>
M:	Serge Semin <fancer.lancer@gmail.com>
L:	linux-mips@vger.kernel.org
S:	Supported
F:	drivers/bus/mips_cdmm.c
F:	drivers/clocksource/mips-gic-timer.c
F:	drivers/cpuidle/cpuidle-cps.c
F:	drivers/irqchip/irq-mips-cpu.c
F:	drivers/irqchip/irq-mips-gic.c

MIPS GENERIC PLATFORM
M:	Paul Burton <paulburton@kernel.org>
L:	linux-mips@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/power/mti,mips-cpc.yaml
F:	arch/mips/generic/
F:	arch/mips/tools/generic-board-config.sh

MIPS RINT INSTRUCTION EMULATION
M:	Aleksandar Markovic <aleksandar.markovic@mips.com>
L:	linux-mips@vger.kernel.org
S:	Supported
F:	arch/mips/math-emu/dp_rint.c
F:	arch/mips/math-emu/sp_rint.c

MIPS/LOONGSON1 ARCHITECTURE
M:	Keguang Zhang <keguang.zhang@gmail.com>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	arch/mips/include/asm/mach-loongson32/
F:	arch/mips/loongson32/
F:	drivers/*/*/*loongson1*
F:	drivers/*/*loongson1*

MIPS/LOONGSON2EF ARCHITECTURE
M:	Jiaxun Yang <jiaxun.yang@flygoat.com>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	arch/mips/include/asm/mach-loongson2ef/
F:	arch/mips/loongson2ef/
F:	drivers/cpufreq/loongson2_cpufreq.c

MIPS/LOONGSON64 ARCHITECTURE
M:	Huacai Chen <chenhuacai@kernel.org>
M:	Jiaxun Yang <jiaxun.yang@flygoat.com>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	arch/mips/include/asm/mach-loongson64/
F:	arch/mips/loongson64/
F:	drivers/irqchip/irq-loongson*
F:	drivers/platform/mips/cpu_hwmon.c

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

MMP SUPPORT
R:	Lubomir Rintel <lkundrak@v3.sk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Odd Fixes
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lkundrak/linux-mmp.git
F:	arch/arm/boot/dts/mmp*
F:	arch/arm/mach-mmp/
F:	include/linux/soc/mmp/

MMP USB PHY DRIVERS
R:	Lubomir Rintel <lkundrak@v3.sk>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/phy/marvell/phy-mmp3-usb.c
F:	drivers/phy/marvell/phy-pxa-usb.c

MMU GATHER AND TLB INVALIDATION
M:	Will Deacon <will@kernel.org>
M:	"Aneesh Kumar K.V" <aneesh.kumar@linux.ibm.com>
M:	Andrew Morton <akpm@linux-foundation.org>
M:	Nick Piggin <npiggin@gmail.com>
M:	Peter Zijlstra <peterz@infradead.org>
L:	linux-arch@vger.kernel.org
L:	linux-mm@kvack.org
S:	Maintained
F:	arch/*/include/asm/tlb.h
F:	include/asm-generic/tlb.h
F:	mm/mmu_gather.c

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

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

MODULE SUPPORT
M:	Luis Chamberlain <mcgrof@kernel.org>
L:	linux-modules@vger.kernel.org
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mcgrof/linux.git modules-next
F:	include/linux/module.h
F:	kernel/module/

MONOLITHIC POWER SYSTEM PMIC DRIVER
M:	Saravanan Sekar <sravanhome@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/mfd/mps,mp2629.yaml
F:	Documentation/devicetree/bindings/regulator/mps,mp*.yaml
F:	drivers/iio/adc/mp2629_adc.c
F:	drivers/mfd/mp2629.c
F:	drivers/power/supply/mp2629_charger.c
F:	drivers/regulator/mp5416.c
F:	drivers/regulator/mpq7920.c
F:	drivers/regulator/mpq7920.h
F:	include/linux/mfd/mp2629.h

MOTION EYE VAIO PICTUREBOOK CAMERA DRIVER
S:	Orphan
W:	http://popies.net/meye/
F:	Documentation/userspace-api/media/drivers/meye*
F:	drivers/media/pci/meye/
F:	include/uapi/linux/meye.h

MOTORCOMM PHY DRIVER
M:	Peter Geis <pgwipeout@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/phy/motorcomm.c

MOXA SMARTIO/INDUSTIO/INTELLIO SERIAL CARD
M:	Jiri Slaby <jirislaby@kernel.org>
S:	Maintained
F:	Documentation/driver-api/tty/moxa-smartio.rst
F:	drivers/tty/mxser.*

MR800 AVERMEDIA USB FM RADIO DRIVER
M:	Alexey Klimov <klimov.linux@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
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:	Documentation/devicetree/bindings/net/ieee802154/mrf24j40.txt
F:	drivers/net/ieee802154/mrf24j40.c

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
S:	Maintained
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
F:	drivers/media/tuners/msi001*

MSI2500 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/usb/msi2500/

MSTAR INTERRUPT CONTROLLER DRIVER
M:	Mark-PK Tsai <mark-pk.tsai@mediatek.com>
M:	Daniel Palmer <daniel@thingy.jp>
S:	Maintained
F:	Documentation/devicetree/bindings/interrupt-controller/mstar,mst-intc.yaml
F:	drivers/irqchip/irq-mst-intc.c

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
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
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
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/aptina,mt9p031.yaml
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
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
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
S:	Odd Fixes
T:	git git://linuxtv.org/media_tree.git
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
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/mt9v032.txt
F:	drivers/media/i2c/mt9v032.c
F:	include/media/i2c/mt9v032.h

MT9V111 APTINA CAMERA SENSOR
M:	Jacopo Mondi <jacopo@jmondi.org>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/aptina,mt9v111.yaml
F:	drivers/media/i2c/mt9v111.c

MULTIFUNCTION DEVICES (MFD)
M:	Lee Jones <lee.jones@linaro.org>
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd.git
F:	Documentation/devicetree/bindings/mfd/
F:	drivers/mfd/
F:	include/dt-bindings/mfd/
F:	include/linux/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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ulfh/mmc.git
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/sysfs-class-mux*
F:	Documentation/devicetree/bindings/mux/
F:	drivers/mux/
F:	include/dt-bindings/mux/
F:	include/linux/mux/

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/

MXL301RF MEDIA DRIVER
M:	Akihiro Tsukada <tskd08@gmail.com>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
F:	drivers/media/tuners/mxl301rf*

MXL5007T MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/tuners/mxl5007t.*

MXSFB DRM DRIVER
M:	Marek Vasut <marex@denx.de>
M:	Stefan Agner <stefan@agner.ch>
L:	dri-devel@lists.freedesktop.org
S:	Supported
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/devicetree/bindings/display/fsl,lcdif.yaml
F:	drivers/gpu/drm/mxsfb/

MYLEX DAC960 PCI RAID Controller
M:	Hannes Reinecke <hare@kernel.org>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/myrb.*
F:	drivers/scsi/myrs.*

MYRICOM MYRI-10G 10GbE DRIVER (MYRI10GE)
M:	Chris Lee <christopher.lee@cspi.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	https://www.cspi.com/ethernet-products/support/downloads/
F:	drivers/net/ethernet/myricom/myri10ge/

NAND FLASH SUBSYSTEM
M:	Miquel Raynal <miquel.raynal@bootlin.com>
R:	Richard Weinberger <richard@nod.at>
L:	linux-mtd@lists.infradead.org
S:	Maintained
W:	http://www.linux-mtd.infradead.org/
Q:	http://patchwork.ozlabs.org/project/linux-mtd/list/
C:	irc://irc.oftc.net/mtd
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mtd/linux.git nand/next
F:	drivers/mtd/nand/
F:	include/linux/mtd/*nand*.h

NATIVE INSTRUMENTS USB SOUND INTERFACE DRIVER
M:	Daniel Mack <zonque@gmail.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
W:	http://www.native-instruments.com
F:	sound/usb/caiaq/

NATSEMI ETHERNET DRIVER (DP8381x)
S:	Orphan
F:	drivers/net/ethernet/natsemi/natsemi.c

NCR 5380 SCSI DRIVERS
M:	Finn Thain <fthain@linux-m68k.org>
M:	Michael Schmitz <schmitzmic@gmail.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	Documentation/scsi/g_NCR5380.rst
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

NCSI LIBRARY
M:	Samuel Mendoza-Jonas <sam@mendozajonas.com>
S:	Maintained
F:	net/ncsi/

NCT6775 HARDWARE MONITOR DRIVER - CORE & PLATFORM DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/nct6775.rst
F:	drivers/hwmon/nct6775-core.c
F:	drivers/hwmon/nct6775-platform.c
F:	drivers/hwmon/nct6775.h

NCT6775 HARDWARE MONITOR DRIVER - I2C DRIVER
M:	Zev Weiss <zev@bewilderbeest.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/hwmon/nuvoton,nct6775.yaml
F:	drivers/hwmon/nct6775-i2c.c

NETDEVSIM
M:	Jakub Kicinski <kuba@kernel.org>
S:	Maintained
F:	drivers/net/netdevsim/*

NETEM NETWORK EMULATOR
M:	Stephen Hemminger <stephen@networkplumber.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	net/sched/sch_netem.c

NETERION 10GbE DRIVERS (s2io)
M:	Jon Mason <jdmason@kudzu.us>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/device_drivers/ethernet/neterion/s2io.rst
F:	drivers/net/ethernet/neterion/

NETFILTER
M:	Pablo Neira Ayuso <pablo@netfilter.org>
M:	Jozsef Kadlecsik <kadlec@netfilter.org>
M:	Florian Westphal <fw@strlen.de>
L:	netfilter-devel@vger.kernel.org
L:	coreteam@netfilter.org
S:	Maintained
W:	http://www.netfilter.org/
W:	http://www.iptables.org/
W:	http://www.nftables.org/
Q:	http://patchwork.ozlabs.org/project/netfilter-devel/list/
C:	irc://irc.libera.chat/netfilter
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf-next.git
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/bridge/br_netfilter*.c
F:	net/netfilter/

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

NETRONIX EMBEDDED CONTROLLER
M:	Jonathan Neuschäfer <j.neuschaefer@gmx.net>
S:	Maintained
F:	Documentation/devicetree/bindings/mfd/netronix,ntxec.yaml
F:	drivers/mfd/ntxec.c
F:	drivers/pwm/pwm-ntxec.c
F:	drivers/rtc/rtc-ntxec.c
F:	include/linux/mfd/ntxec.h

NETRONOME ETHERNET DRIVERS
M:	Simon Horman <simon.horman@corigine.com>
R:	Jakub Kicinski <kuba@kernel.org>
L:	oss-drivers@corigine.com
S:	Maintained
F:	drivers/net/ethernet/netronome/

NETWORK BLOCK DEVICE (NBD)
M:	Josef Bacik <josef@toxicpanda.com>
L:	linux-block@vger.kernel.org
L:	nbd@other.debian.org
S:	Maintained
F:	Documentation/admin-guide/blockdev/nbd.rst
F:	drivers/block/nbd.c
F:	include/trace/events/nbd.h
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:	include/uapi/linux/net_dropmon.h
F:	net/core/drop_monitor.c

NETWORKING DRIVERS
M:	"David S. Miller" <davem@davemloft.net>
M:	Eric Dumazet <edumazet@google.com>
M:	Jakub Kicinski <kuba@kernel.org>
M:	Paolo Abeni <pabeni@redhat.com>
L:	netdev@vger.kernel.org
S:	Maintained
Q:	https://patchwork.kernel.org/project/netdevbpf/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git
F:	Documentation/devicetree/bindings/net/
F:	drivers/connector/
F:	drivers/net/
F:	include/dt-bindings/net/
F:	include/linux/etherdevice.h
F:	include/linux/fcdevice.h
F:	include/linux/fddidevice.h
F:	include/linux/hippidevice.h
F:	include/linux/if_*
F:	include/linux/inetdevice.h
F:	include/linux/netdevice.h
F:	include/uapi/linux/if_*
F:	include/uapi/linux/netdevice.h

NETWORKING DRIVERS (WIRELESS)
M:	Kalle Valo <kvalo@kernel.org>
L:	linux-wireless@vger.kernel.org
S:	Maintained
W:	https://wireless.wiki.kernel.org/
Q:	https://patchwork.kernel.org/project/linux-wireless/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/wireless/wireless.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/wireless/wireless-next.git
F:	Documentation/devicetree/bindings/net/wireless/
F:	drivers/net/wireless/

NETWORKING [DSA]
M:	Andrew Lunn <andrew@lunn.ch>
M:	Vivien Didelot <vivien.didelot@gmail.com>
M:	Florian Fainelli <f.fainelli@gmail.com>
M:	Vladimir Oltean <olteanv@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/net/dsa/
F:	drivers/net/dsa/
F:	include/linux/dsa/
F:	include/linux/platform_data/dsa.h
F:	include/net/dsa.h
F:	net/dsa/
F:	tools/testing/selftests/drivers/net/dsa/

NETWORKING [GENERAL]
M:	"David S. Miller" <davem@davemloft.net>
M:	Eric Dumazet <edumazet@google.com>
M:	Jakub Kicinski <kuba@kernel.org>
M:	Paolo Abeni <pabeni@redhat.com>
L:	netdev@vger.kernel.org
S:	Maintained
Q:	https://patchwork.kernel.org/project/netdevbpf/list/
B:	mailto:netdev@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git
F:	Documentation/networking/
F:	Documentation/process/maintainer-netdev.rst
F:	include/linux/in.h
F:	include/linux/net.h
F:	include/linux/netdevice.h
F:	include/net/
F:	include/uapi/linux/in.h
F:	include/uapi/linux/net.h
F:	include/uapi/linux/net_namespace.h
F:	include/uapi/linux/netdevice.h
F:	lib/net_utils.c
F:	lib/random32.c
F:	net/
F:	tools/testing/selftests/net/

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
S:	Maintained
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
F:	include/net/xfrm.h
F:	include/uapi/linux/xfrm.h
F:	net/ipv4/ah4.c
F:	net/ipv4/esp4*
F:	net/ipv4/ip_vti.c
F:	net/ipv4/ipcomp.c
F:	net/ipv4/xfrm*
F:	net/ipv6/ah6.c
F:	net/ipv6/esp6*
F:	net/ipv6/ip6_vti.c
F:	net/ipv6/ipcomp6.c
F:	net/ipv6/xfrm*
F:	net/key/
F:	net/xfrm/
F:	tools/testing/selftests/net/ipsec.c

NETWORKING [IPv4/IPv6]
M:	"David S. Miller" <davem@davemloft.net>
M:	Hideaki YOSHIFUJI <yoshfuji@linux-ipv6.org>
M:	David Ahern <dsahern@kernel.org>
L:	netdev@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git
F:	arch/x86/net/*
F:	include/linux/ip.h
F:	include/linux/ipv6*
F:	include/net/fib*
F:	include/net/ip*
F:	include/net/route.h
F:	net/ipv4/
F:	net/ipv6/

NETWORKING [LABELED] (NetLabel, Labeled IPsec, SECMARK)
M:	Paul Moore <paul@paul-moore.com>
L:	netdev@vger.kernel.org
L:	linux-security-module@vger.kernel.org
S:	Maintained
W:	https://github.com/netlabel
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_CONNSECMARK.h
F:	include/uapi/linux/netfilter/xt_SECMARK.h
F:	net/ipv4/cipso_ipv4.c
F:	net/ipv6/calipso.c
F:	net/netfilter/xt_CONNSECMARK.c
F:	net/netfilter/xt_SECMARK.c
F:	net/netlabel/

NETWORKING [MPTCP]
M:	Mat Martineau <mathew.j.martineau@linux.intel.com>
M:	Matthieu Baerts <matthieu.baerts@tessares.net>
L:	netdev@vger.kernel.org
L:	mptcp@lists.linux.dev
S:	Maintained
W:	https://github.com/multipath-tcp/mptcp_net-next/wiki
B:	https://github.com/multipath-tcp/mptcp_net-next/issues
F:	Documentation/networking/mptcp-sysctl.rst
F:	include/net/mptcp.h
F:	include/trace/events/mptcp.h
F:	include/uapi/linux/mptcp.h
F:	net/mptcp/
F:	tools/testing/selftests/bpf/*/*mptcp*.c
F:	tools/testing/selftests/net/mptcp/

NETWORKING [TCP]
M:	Eric Dumazet <edumazet@google.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	include/linux/tcp.h
F:	include/net/tcp.h
F:	include/trace/events/tcp.h
F:	include/uapi/linux/tcp.h
F:	net/ipv4/syncookies.c
F:	net/ipv4/tcp*.c
F:	net/ipv6/syncookies.c
F:	net/ipv6/tcp*.c

NETWORKING [TLS]
M:	Boris Pismenny <borisp@nvidia.com>
M:	John Fastabend <john.fastabend@gmail.com>
M:	Jakub Kicinski <kuba@kernel.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	include/net/tls.h
F:	include/uapi/linux/tls.h
F:	net/tls/*

NETXEN (1/10) GbE SUPPORT
M:	Manish Chopra <manishc@marvell.com>
M:	Rahul Verma <rahulv@marvell.com>
M:	GR-Linux-NIC-Dev@marvell.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/qlogic/netxen/

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

NEXTHOP
M:	David Ahern <dsahern@kernel.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	include/net/netns/nexthop.h
F:	include/net/nexthop.h
F:	include/uapi/linux/nexthop.h
F:	net/ipv4/nexthop.c

NFC SUBSYSTEM
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
L:	linux-nfc@lists.01.org (subscribers-only)
L:	netdev@vger.kernel.org
S:	Maintained
B:	mailto:linux-nfc@lists.01.org
F:	Documentation/devicetree/bindings/net/nfc/
F:	drivers/nfc/
F:	include/linux/platform_data/nfcmrvl.h
F:	include/net/nfc/
F:	include/uapi/linux/nfc.h
F:	net/nfc/

NFC VIRTUAL NCI DEVICE DRIVER
M:	Bongsu Jeon <bongsu.jeon@samsung.com>
L:	netdev@vger.kernel.org
L:	linux-nfc@lists.01.org (subscribers-only)
S:	Supported
F:	drivers/nfc/virtual_ncidev.c
F:	tools/testing/selftests/nci/

NFS, SUNRPC, AND LOCKD CLIENTS
M:	Trond Myklebust <trond.myklebust@hammerspace.com>
M:	Anna Schumaker <anna@kernel.org>
L:	linux-nfs@vger.kernel.org
S:	Maintained
W:	http://client.linux-nfs.org
T:	git git://git.linux-nfs.org/projects/trondmy/linux-nfs.git
F:	fs/lockd/
F:	fs/nfs/
F:	fs/nfs_common/
F:	include/linux/lockd/
F:	include/linux/nfs*
F:	include/linux/sunrpc/
F:	include/uapi/linux/nfs*
F:	include/uapi/linux/sunrpc/
F:	net/sunrpc/
F:	Documentation/filesystems/nfs/

NILFS2 FILESYSTEM
M:	Ryusuke Konishi <konishi.ryusuke@gmail.com>
L:	linux-nilfs@vger.kernel.org
S:	Supported
W:	https://nilfs.sourceforge.io/
W:	https://nilfs.osdn.jp/
T:	git git://github.com/konis/nilfs2.git
F:	Documentation/filesystems/nilfs2.rst
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>
S:	Maintained
W:	http://www.netlab.is.tsukuba.ac.jp/~yokota/izumi/ninja/
F:	Documentation/scsi/NinjaSCSI.rst
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>
S:	Maintained
W:	http://www.netlab.is.tsukuba.ac.jp/~yokota/izumi/ninja/
F:	Documentation/scsi/NinjaSCSI.rst
F:	drivers/scsi/nsp32*

NINTENDO HID DRIVER
M:	Daniel J. Ogorchock <djogorchock@gmail.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/hid-nintendo*

NIOS2 ARCHITECTURE
M:	Dinh Nguyen <dinguyen@kernel.org>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dinguyen/linux.git
F:	arch/nios2/

NITRO ENCLAVES (NE)
M:	Andra Paraschiv <andraprs@amazon.com>
M:	Alexandru Vasile <lexnv@amazon.com>
M:	Alexandru Ciobotaru <alcioa@amazon.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
W:	https://aws.amazon.com/ec2/nitro/nitro-enclaves/
F:	Documentation/virt/ne_overview.rst
F:	drivers/virt/nitro_enclaves/
F:	include/linux/nitro_enclaves.h
F:	include/uapi/linux/nitro_enclaves.h
F:	samples/nitro_enclaves/

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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/nohz
F:	include/linux/sched/nohz.h
F:	include/linux/tick.h
F:	kernel/time/tick*.*

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/ad5820.c
F:	drivers/media/i2c/et8ek8

NOKIA N900 POWER SUPPLY DRIVERS
R:	Pali Rohár <pali@kernel.org>
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
F:	include/linux/power/bq2415x_charger.h
F:	include/linux/power/bq27xxx_battery.h

NOLIBC HEADER FILE
M:	Willy Tarreau <w@1wt.eu>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/wtarreau/nolibc.git
F:	tools/include/nolibc/

NSDEPS
M:	Matthias Maennich <maennich@google.com>
S:	Maintained
F:	Documentation/core-api/symbol-namespaces.rst
F:	scripts/nsdeps

NTB AMD DRIVER
M:	Sanjay R Mehta <sanju.mehta@amd.com>
M:	Shyam Sundar S K <Shyam-sundar.S-k@amd.com>
L:	ntb@lists.linux.dev
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:	ntb@lists.linux.dev
S:	Supported
W:	https://github.com/jonmason/ntb/wiki
T:	git git://github.com/jonmason/ntb.git
F:	drivers/net/ntb_netdev.c
F:	drivers/ntb/
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:	ntb@lists.linux.dev
S:	Supported
F:	drivers/ntb/hw/idt/

NTB INTEL DRIVER
M:	Dave Jiang <dave.jiang@intel.com>
L:	ntb@lists.linux.dev
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
S:	Supported
W:	http://www.tuxera.com/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/aia21/ntfs.git
F:	Documentation/filesystems/ntfs.rst
F:	fs/ntfs/

NTFS3 FILESYSTEM
M:	Konstantin Komarov <almaz.alexandrovich@paragon-software.com>
L:	ntfs3@lists.linux.dev
S:	Supported
W:	http://www.paragon-software.com/
T:	git https://github.com/Paragon-Software-Group/linux-ntfs3.git
F:	Documentation/filesystems/ntfs3.rst
F:	fs/ntfs3/

NUBUS SUBSYSTEM
M:	Finn Thain <fthain@linux-m68k.org>
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/nvidia/
F:	drivers/video/fbdev/riva/

NVIDIA WMI EC BACKLIGHT DRIVER
M:	Daniel Dadap <ddadap@nvidia.com>
L:	platform-driver-x86@vger.kernel.org
S:	Supported
F:	drivers/platform/x86/nvidia-wmi-ec-backlight.c

NVM EXPRESS DRIVER
M:	Keith Busch <kbusch@kernel.org>
M:	Jens Axboe <axboe@fb.com>
M:	Christoph Hellwig <hch@lst.de>
M:	Sagi Grimberg <sagi@grimberg.me>
L:	linux-nvme@lists.infradead.org
S:	Supported
W:	http://git.infradead.org/nvme.git
T:	git://git.infradead.org/nvme.git
F:	drivers/nvme/host/
F:	drivers/nvme/common/
F:	include/linux/nvme*
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:	drivers/nvme/host/fc.c
F:	drivers/nvme/target/fc.c
F:	drivers/nvme/target/fcloop.c
F:	include/linux/nvme-fc-driver.h
F:	include/linux/nvme-fc.h

NVM EXPRESS TARGET DRIVER
M:	Christoph Hellwig <hch@lst.de>
M:	Sagi Grimberg <sagi@grimberg.me>
M:	Chaitanya Kulkarni <kch@nvidia.com>
L:	linux-nvme@lists.infradead.org
S:	Supported
W:	http://git.infradead.org/nvme.git
T:	git://git.infradead.org/nvme.git
F:	drivers/nvme/target/

NVMEM FRAMEWORK
M:	Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/srini/nvmem.git
F:	Documentation/ABI/stable/sysfs-bus-nvmem
F:	Documentation/devicetree/bindings/nvmem/
F:	drivers/nvmem/
F:	include/linux/nvmem-consumer.h
F:	include/linux/nvmem-provider.h

NXP C45 TJA11XX PHY DRIVER
M:	Radu Pirea <radu-nicolae.pirea@oss.nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/phy/nxp-c45-tja11xx.c

NXP FSPI DRIVER
M:	Han Xu <han.xu@nxp.com>
M:	Haibo Chen <haibo.chen@nxp.com>
R:	Yogesh Gaur <yogeshgaur.83@gmail.com>
L:	linux-spi@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/spi/spi-nxp-fspi.yaml
F:	drivers/spi/spi-nxp-fspi.c

NXP FXAS21002C DRIVER
M:	Rui Miguel Silva <rmfrfs@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/gyroscope/nxp,fxas21002c.yaml
F:	drivers/iio/gyro/fxas21002c.h
F:	drivers/iio/gyro/fxas21002c_core.c
F:	drivers/iio/gyro/fxas21002c_i2c.c
F:	drivers/iio/gyro/fxas21002c_spi.c

NXP i.MX CLOCK DRIVERS
M:	Abel Vesa <abelvesa@kernel.org>
L:	linux-clk@vger.kernel.org
L:	linux-imx@nxp.com
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/abelvesa/linux.git clk/imx
F:	Documentation/devicetree/bindings/clock/imx*
F:	drivers/clk/imx/
F:	include/dt-bindings/clock/imx*

NXP i.MX 8MQ DCSS DRIVER
M:	Laurentiu Palcu <laurentiu.palcu@oss.nxp.com>
R:	Lucas Stach <l.stach@pengutronix.de>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
F:	Documentation/devicetree/bindings/display/imx/nxp,imx8mq-dcss.yaml
F:	drivers/gpu/drm/imx/dcss/

NXP i.MX 8QXP ADC DRIVER
M:	Cai Huoqing <cai.huoqing@linux.dev>
M:	Haibo Chen <haibo.chen@nxp.com>
L:	linux-imx@nxp.com
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/adc/nxp,imx8qxp-adc.yaml
F:	drivers/iio/adc/imx8qxp-adc.c

NXP i.MX 7D/6SX/6UL AND VF610 ADC DRIVER
M:	Haibo Chen <haibo.chen@nxp.com>
L:	linux-iio@vger.kernel.org
L:	linux-imx@nxp.com
S:	Maintained
F:	Documentation/devicetree/bindings/iio/adc/fsl,imx7d-adc.yaml
F:	Documentation/devicetree/bindings/iio/adc/fsl,vf610-adc.yaml
F:	drivers/iio/adc/imx7d_adc.c
F:	drivers/iio/adc/vf610_adc.c

NXP PF8100/PF8121A/PF8200 PMIC REGULATOR DEVICE DRIVER
M:	Jagan Teki <jagan@amarulasolutions.com>
S:	Maintained
F:	Documentation/devicetree/bindings/regulator/nxp,pf8x00-regulator.yaml
F:	drivers/regulator/pf8x00-regulator.c

NXP PTN5150A CC LOGIC AND EXTCON DRIVER
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/extcon/extcon-ptn5150.yaml
F:	drivers/extcon/extcon-ptn5150.c

NXP SGTL5000 DRIVER
M:	Fabio Estevam <festevam@gmail.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/sound/sgtl5000.yaml
F:	sound/soc/codecs/sgtl5000*

NXP SJA1105 ETHERNET SWITCH DRIVER
M:	Vladimir Oltean <olteanv@gmail.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/net/dsa/sja1105
F:	drivers/net/pcs/pcs-xpcs-nxp.c

NXP TDA998X DRM DRIVER
M:	Russell King <linux@armlinux.org.uk>
S:	Maintained
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
F:	include/dt-bindings/display/tda998x.h
K:	"nxp,tda998x"

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/Goodix TFA989X (TFA1) DRIVER
M:	Stephan Gerhold <stephan@gerhold.net>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/sound/nxp,tfa989x.yaml
F:	sound/soc/codecs/tfa989x.c

NXP-NCI NFC DRIVER
L:	linux-nfc@lists.01.org (subscribers-only)
S:	Orphan
F:	Documentation/devicetree/bindings/net/nfc/nxp,nci.yaml
F:	drivers/nfc/nxp-nci

NXP i.MX 8QXP/8QM JPEG V4L2 DRIVER
M:	Mirela Rabulea <mirela.rabulea@nxp.com>
R:	NXP Linux Team <linux-imx@nxp.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/nxp,imx8-jpeg.yaml
F:	drivers/media/platform/nxp/imx-jpeg

NZXT-KRAKEN2 HARDWARE MONITORING DRIVER
M:	Jonas Malaco <jonas@protocubo.io>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/nzxt-kraken2.rst
F:	drivers/hwmon/nzxt-kraken2.c

NZXT-SMART2 HARDWARE MONITORING DRIVER
M:	Aleksandr Mezin <mezin.alexander@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/nzxt-smart2.rst
F:	drivers/hwmon/nzxt-smart2.c

OBJAGG
M:	Jiri Pirko <jiri@nvidia.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	include/linux/objagg.h
F:	lib/objagg.c
F:	lib/test_objagg.c

OBJTOOL
M:	Josh Poimboeuf <jpoimboe@kernel.org>
M:	Peter Zijlstra <peterz@infradead.org>
S:	Supported
F:	tools/objtool/
F:	include/linux/objtool.h

OCELOT ETHERNET SWITCH DRIVER
M:	Vladimir Oltean <vladimir.oltean@nxp.com>
M:	Claudiu Manoil <claudiu.manoil@nxp.com>
M:	Alexandre Belloni <alexandre.belloni@bootlin.com>
M:	UNGLinuxDriver@microchip.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/dsa/ocelot/*
F:	drivers/net/ethernet/mscc/
F:	include/soc/mscc/ocelot*
F:	net/dsa/tag_ocelot.c
F:	net/dsa/tag_ocelot_8021q.c
F:	tools/testing/selftests/drivers/net/ocelot/*

OCXL (Open Coherent Accelerator Processor Interface OpenCAPI) DRIVER
M:	Frederic Barrat <fbarrat@linux.ibm.com>
M:	Andrew Donnellan <ajd@linux.ibm.com>
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
F:	Documentation/userspace-api/accelerators/ocxl.rst
F:	arch/powerpc/include/asm/pnv-ocxl.h
F:	arch/powerpc/platforms/powernv/ocxl.c
F:	drivers/misc/ocxl/
F:	include/misc/ocxl*
F:	include/uapi/misc/ocxl.h

OMAP AUDIO SUPPORT
M:	Peter Ujfalusi <peter.ujfalusi@gmail.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/ti/n810.c
F:	sound/soc/ti/omap*
F:	sound/soc/ti/rx51.c
F:	sound/soc/ti/sdma-pcm.*

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/*am3*
F:	arch/arm/boot/dts/*am4*
F:	arch/arm/boot/dts/*am5*
F:	arch/arm/boot/dts/*dra7*
F:	arch/arm/boot/dts/*omap*
F:	arch/arm/boot/dts/logicpd-som-lv*
F:	arch/arm/boot/dts/logicpd-torpedo*

OMAP DISPLAY SUBSYSTEM and FRAMEBUFFER SUPPORT (DSS2)
L:	linux-omap@vger.kernel.org
L:	linux-fbdev@vger.kernel.org
S:	Orphan
F:	Documentation/arm/omap/dss.rst
F:	drivers/video/fbdev/omap2/

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@kernel.org>
M:	Tony Lindgren <tony@atomide.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
F:	arch/arm/mach-omap2/*gpmc*
F:	drivers/memory/omap-gpmc.c

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/ti,omap-gpio.yaml
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 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 I2C DRIVER
M:	Vignesh R <vigneshr@ti.com>
L:	linux-omap@vger.kernel.org
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/ti,omap4-i2c.yaml
F:	drivers/i2c/busses/i2c-omap.c

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/ti/omap3isp/
F:	drivers/staging/media/omap4iss/

OMAP MMC SUPPORT
M:	Aaro Koskinen <aaro.koskinen@iki.fi>
L:	linux-omap@vger.kernel.org
S:	Odd Fixes
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:	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:	arch/arm/*omap*/usb*
F:	drivers/usb/*/*omap*

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:	Janusz Krzysztofik <jmkrzyszt@gmail.com>
M:	Tony Lindgren <tony@atomide.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
Q:	http://patchwork.kernel.org/project/linux-omap/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tmlind/linux-omap.git
F:	arch/arm/configs/omap1_defconfig
F:	arch/arm/mach-omap1/
F:	arch/arm/plat-omap/
F:	drivers/i2c/busses/i2c-omap.c
F:	include/linux/platform_data/ams-delta-fiq.h
F:	include/linux/platform_data/i2c-omap.h

OMAP2+ SUPPORT
M:	Tony Lindgren <tony@atomide.com>
L:	linux-omap@vger.kernel.org
S:	Maintained
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
F:	arch/arm/configs/omap2plus_defconfig
F:	arch/arm/mach-omap2/
F:	arch/arm/plat-omap/
F:	drivers/bus/ti-sysc.c
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
F:	include/linux/platform_data/ti-sysc.h

OMFS FILESYSTEM
M:	Bob Copeland <me@bobcopeland.com>
L:	linux-karma-devel@lists.sourceforge.net
S:	Maintained
F:	Documentation/filesystems/omfs.rst
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 OG01A1B SENSOR DRIVER
M:	Shawn Tu <shawnx.tu@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/og01a1b.c

OMNIVISION OV02A10 SENSOR DRIVER
M:	Dongchun Zhu <dongchun.zhu@mediatek.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ovti,ov02a10.yaml
F:	drivers/media/i2c/ov02a10.c

OMNIVISION OV08D10 SENSOR DRIVER
M:	Jimmy Su <jimmy.su@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/ov08d10.c

OMNIVISION OV13858 SENSOR DRIVER
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/ov13858.c

OMNIVISION OV13B10 SENSOR DRIVER
M:	Arec Kao <arec.kao@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/ov13b10.c

OMNIVISION OV2680 SENSOR DRIVER
M:	Rui Miguel Silva <rmfrfs@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ovti,ov2680.yaml
F:	drivers/media/i2c/ov2680.c

OMNIVISION OV2685 SENSOR DRIVER
M:	Shunqian Zheng <zhengsq@rock-chips.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/ov2685.c

OMNIVISION OV2740 SENSOR DRIVER
M:	Tianshu Qiu <tian.shu.qiu@intel.com>
R:	Shawn Tu <shawnx.tu@intel.com>
R:	Bingbu Cao <bingbu.cao@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/ov2740.c

OMNIVISION OV5640 SENSOR DRIVER
M:	Steve Longerbeam <slongerbeam@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/ov5640.c

OMNIVISION OV5647 SENSOR DRIVER
M:	Dave Stevenson <dave.stevenson@raspberrypi.com>
M:	Jacopo Mondi <jacopo@jmondi.org>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ovti,ov5647.yaml
F:	drivers/media/i2c/ov5647.c

OMNIVISION OV5670 SENSOR DRIVER
M:	Chiranjeevi Rapolu <chiranjeevi.rapolu@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/ov5670.c

OMNIVISION OV5675 SENSOR DRIVER
M:	Shawn Tu <shawnx.tu@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/ov5675.c

OMNIVISION OV5693 SENSOR DRIVER
M:	Daniel Scally <djrscally@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ovti,ov5693.yaml
F:	drivers/media/i2c/ov5693.c

OMNIVISION OV5695 SENSOR DRIVER
M:	Shunqian Zheng <zhengsq@rock-chips.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/ov5695.c

OMNIVISION OV7670 SENSOR DRIVER
L:	linux-media@vger.kernel.org
S:	Orphan
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ov7670.txt
F:	drivers/media/i2c/ov7670.c

OMNIVISION OV772x SENSOR DRIVER
M:	Jacopo Mondi <jacopo@jmondi.org>
L:	linux-media@vger.kernel.org
S:	Odd fixes
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ovti,ov772x.yaml
F:	drivers/media/i2c/ov772x.c
F:	include/media/i2c/ov772x.h

OMNIVISION OV7740 SENSOR DRIVER
M:	Wenyou Yang <wenyou.yang@microchip.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ov7740.txt
F:	drivers/media/i2c/ov7740.c

OMNIVISION OV8856 SENSOR DRIVER
M:	Dongchun Zhu <dongchun.zhu@mediatek.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ov8856.yaml
F:	drivers/media/i2c/ov8856.c

OMNIVISION OV9282 SENSOR DRIVER
M:	Paul J. Murphy <paul.j.murphy@intel.com>
M:	Daniele Alessandrelli <daniele.alessandrelli@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ovti,ov9282.yaml
F:	drivers/media/i2c/ov9282.c

OMNIVISION OV9640 SENSOR DRIVER
M:	Petr Cvek <petrcvekcz@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/i2c/ov9640.*

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
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/ov9650.txt
F:	drivers/media/i2c/ov9650.c

OMNIVISION OV9734 SENSOR DRIVER
M:	Tianshu Qiu <tian.shu.qiu@intel.com>
R:	Bingbu Cao <bingbu.cao@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/ov9734.c

ONBOARD USB HUB DRIVER
M:	Matthias Kaehlcke <mka@chromium.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-platform-onboard-usb-hub
F:	drivers/usb/misc/onboard_usb_hub.c

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

ONION OMEGA2+ BOARD
M:	Harvey Hunt <harveyhuntnexus@gmail.com>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	arch/mips/boot/dts/ralink/omega2p.dts

OP-TEE DRIVER
M:	Jens Wiklander <jens.wiklander@linaro.org>
L:	op-tee@lists.trustedfirmware.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-optee-devices
F:	drivers/tee/optee/

OP-TEE RANDOM NUMBER GENERATOR (RNG) DRIVER
M:	Sumit Garg <sumit.garg@linaro.org>
L:	op-tee@lists.trustedfirmware.org
S:	Maintained
F:	drivers/char/hw_random/optee-rng.c

OP-TEE RTC DRIVER
M:	Clément Léger <clement.leger@bootlin.com>
L:	linux-rtc@vger.kernel.org
S:	Maintained
F:	drivers/rtc/rtc-optee.c

OPA-VNIC DRIVER
M:	Dennis Dalessandro <dennis.dalessandro@cornelisnetworks.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.rst
F:	Documentation/devicetree/overlay-notes.rst
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
S:	Maintained
C:	irc://irc.libera.chat/devicetree
W:	http://www.devicetree.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git
F:	Documentation/ABI/testing/sysfs-firmware-ofw
F:	drivers/of/
F:	include/linux/of*.h
F:	scripts/dtc/

OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS
M:	Rob Herring <robh+dt@kernel.org>
M:	Krzysztof Kozlowski <krzysztof.kozlowski+dt@linaro.org>
L:	devicetree@vger.kernel.org
S:	Maintained
C:	irc://irc.libera.chat/devicetree
Q:	http://patchwork.ozlabs.org/project/devicetree-bindings/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git
F:	Documentation/devicetree/
F:	arch/*/boot/dts/
F:	include/dt-bindings/

OPENCOMPUTE PTP CLOCK DRIVER
M:	Jonathan Lemon <jonathan.lemon@gmail.com>
M:	Vadim Fedorenko <vadfed@fb.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/ptp/ptp_ocp.c

OPENCORES I2C BUS DRIVER
M:	Peter Korsgaard <peter@korsgaard.com>
M:	Andrew Lunn <andrew@lunn.ch>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/opencores,i2c-ocores.yaml
F:	Documentation/i2c/busses/i2c-ocores.rst
F:	drivers/i2c/busses/i2c-ocores.c
F:	include/linux/platform_data/i2c-ocores.h

OPENRISC ARCHITECTURE
M:	Jonas Bonn <jonas@southpole.se>
M:	Stefan Kristiansson <stefan.kristiansson@saunalahti.fi>
M:	Stafford Horne <shorne@gmail.com>
L:	openrisc@lists.librecores.org
S:	Maintained
W:	http://openrisc.io
T:	git git://github.com/openrisc/linux.git
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
S:	Maintained
W:	http://openvswitch.org
F:	include/uapi/linux/openvswitch.h
F:	net/openvswitch/

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:	Documentation/devicetree/bindings/opp/
F:	Documentation/power/opp.rst
F:	drivers/opp/
F:	include/linux/pm_opp.h

OPL4 DRIVER
M:	Clemens Ladisch <clemens@ladisch.de>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
F:	sound/drivers/opl4/

ORACLE CLUSTER FILESYSTEM 2 (OCFS2)
M:	Mark Fasheh <mark@fasheh.com>
M:	Joel Becker <jlbec@evilplan.org>
M:	Joseph Qi <joseph.qi@linux.alibaba.com>
L:	ocfs2-devel@oss.oracle.com (moderated for non-subscribers)
S:	Supported
W:	http://ocfs2.wiki.kernel.org
F:	Documentation/filesystems/dlmfs.rst
F:	Documentation/filesystems/ocfs2.rst
F:	fs/ocfs2/

ORANGEFS FILESYSTEM
M:	Mike Marshall <hubcap@omnibond.com>
R:	Martin Brandenburg <martin@omnibond.com>
L:	devel@lists.orangefs.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/hubcap/linux.git
F:	Documentation/filesystems/orangefs.rst
F:	fs/orangefs/

ORINOCO DRIVER
L:	linux-wireless@vger.kernel.org
S:	Orphan
W:	https://wireless.wiki.kernel.org/en/users/Drivers/orinoco
W:	http://www.nongnu.org/orinoco/
F:	drivers/net/wireless/intersil/orinoco/

OV2659 OMNIVISION SENSOR DRIVER
M:	"Lad, Prabhakar" <prabhakar.csengg@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mhadli/v4l-dvb-davinci_devices.git
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
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi/vfs.git
F:	Documentation/filesystems/overlayfs.rst
F:	fs/overlayfs/

P54 WIRELESS DRIVER
M:	Christian Lamparter <chunkeey@googlemail.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
W:	https://wireless.wiki.kernel.org/en/users/Drivers/p54
F:	drivers/net/wireless/intersil/p54/

PACKING
M:	Vladimir Oltean <olteanv@gmail.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/core-api/packing.rst
F:	include/linux/packing.h
F:	lib/packing.c

PADATA PARALLEL EXECUTION MECHANISM
M:	Steffen Klassert <steffen.klassert@secunet.com>
M:	Daniel Jordan <daniel.m.jordan@oracle.com>
L:	linux-crypto@vger.kernel.org
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/core-api/padata.rst
F:	include/linux/padata.h
F:	kernel/padata.c

PAGE CACHE
M:	Matthew Wilcox (Oracle) <willy@infradead.org>
L:	linux-fsdevel@vger.kernel.org
S:	Supported
T:	git git://git.infradead.org/users/willy/pagecache.git
F:	Documentation/filesystems/locking.rst
F:	Documentation/filesystems/vfs.rst
F:	include/linux/pagemap.h
F:	mm/filemap.c
F:	mm/page-writeback.c
F:	mm/readahead.c
F:	mm/truncate.c

PAGE POOL
M:	Jesper Dangaard Brouer <hawk@kernel.org>
M:	Ilias Apalodimas <ilias.apalodimas@linaro.org>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/page_pool.rst
F:	include/net/page_pool.h
F:	include/trace/events/page_pool.h
F:	net/core/page_pool.c

PAGE TABLE CHECK
M:	Pasha Tatashin <pasha.tatashin@soleen.com>
M:	Andrew Morton <akpm@linux-foundation.org>
L:	linux-mm@kvack.org
S:	Maintained
F:	Documentation/vm/page_table_check.rst
F:	include/linux/page_table_check.h
F:	mm/page_table_check.c

PANASONIC LAPTOP ACPI EXTRAS DRIVER
M:	Kenneth Chan <kenneth.t.chan@gmail.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/panasonic-laptop.c

PARALLAX PING IIO SENSOR DRIVER
M:	Andreas Klinger <ak@it-klinger.de>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/proximity/parallax-ping.yaml
F:	drivers/iio/proximity/ping.c

PARALLEL LCD/KEYPAD PANEL DRIVER
M:	Willy Tarreau <willy@haproxy.com>
M:	Ksenija Stanojevic <ksenija.stanojevic@gmail.com>
S:	Odd Fixes
F:	Documentation/admin-guide/lcd-panel-cgram.rst
F:	drivers/auxdisplay/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:	Documentation/driver-api/parport*.rst
F:	drivers/char/ppdev.c
F:	drivers/parport/
F:	include/linux/parport*.h
F:	include/uapi/linux/ppdev.h

PARAVIRT_OPS INTERFACE
M:	Juergen Gross <jgross@suse.com>
M:	Srivatsa S. Bhat (VMware) <srivatsa@csail.mit.edu>
R:	Alexey Makhalov <amakhalov@vmware.com>
R:	VMware PV-Drivers Reviewers <pv-drivers@vmware.com>
L:	virtualization@lists.linux-foundation.org
L:	x86@kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86/core
F:	Documentation/virt/paravirt_ops.rst
F:	arch/*/include/asm/paravirt*.h
F:	arch/*/kernel/paravirt*
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/admin-guide/blockdev/paride.rst
F:	drivers/block/paride/

PARISC ARCHITECTURE
M:	"James E.J. Bottomley" <James.Bottomley@HansenPartnership.com>
M:	Helge Deller <deller@gmx.de>
L:	linux-parisc@vger.kernel.org
S:	Maintained
W:	https://parisc.wiki.kernel.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
F:	Documentation/parisc/
F:	arch/parisc/
F:	drivers/char/agp/parisc-agp.c
F:	drivers/input/misc/hp_sdc_rtc.c
F:	drivers/input/serio/gscps2.c
F:	drivers/input/serio/hp_sdc*
F:	drivers/parisc/
F:	drivers/parport/parport_gsc.*
F:	drivers/tty/serial/8250/8250_gsc.c
F:	drivers/video/console/sti*
F:	drivers/video/fbdev/sti*
F:	drivers/video/logo/logo_parisc*
F:	include/linux/hp_sdc.h

PARMAN
M:	Jiri Pirko <jiri@nvidia.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	include/linux/parman.h
F:	lib/parman.c
F:	lib/test_parman.c

PC ENGINES APU BOARD DRIVER
M:	Enrico Weigelt, metux IT consult <info@metux.net>
S:	Maintained
F:	drivers/platform/x86/pcengines-apuv2.c

PC87360 HARDWARE MONITORING DRIVER
M:	Jim Cromie <jim.cromie@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/pc87360.rst
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.rst
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@bootlin.com>
M:	Pali Rohár <pali@kernel.org>
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:	Joyce Ooi <joyce.ooi@intel.com>
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:	Toan Le <toan@os.amperecomputing.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/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 (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/pci/versatile.yaml
F:	drivers/pci/controller/pci-versatile.c

PCI DRIVER FOR ARMADA 8K
M:	Thomas Petazzoni <thomas.petazzoni@bootlin.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/pci-armada8k.txt
F:	drivers/pci/controller/dwc/pcie-armada8k.c

PCI DRIVER FOR CADENCE PCIE IP
M:	Tom Joseph <tjoseph@cadence.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/cdns,*
F:	drivers/pci/controller/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 (moderated for non-subscribers)
S:	Maintained
F:	drivers/pci/controller/dwc/*layerscape*

PCI DRIVER FOR GENERIC OF HOSTS
M:	Will Deacon <will@kernel.org>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/pci/host-generic-pci.yaml
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.yaml
F:	drivers/pci/controller/dwc/*imx6*

PCI DRIVER FOR FU740
M:	Paul Walmsley <paul.walmsley@sifive.com>
M:	Greentime Hu <greentime.hu@sifive.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/sifive,fu740-pcie.yaml
F:	drivers/pci/controller/dwc/pcie-fu740.c

PCI DRIVER FOR INTEL IXP4XX
M:	Linus Walleij <linus.walleij@linaro.org>
S:	Maintained
F:	Documentation/devicetree/bindings/pci/intel,ixp4xx-pci.yaml
F:	drivers/pci/controller/pci-ixp4xx.c

PCI DRIVER FOR INTEL VOLUME MANAGEMENT DEVICE (VMD)
M:	Nirmal Patel <nirmal.patel@linux.intel.com>
R:	Jonathan Derrick <jonathan.derrick@linux.dev>
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/ABI/testing/sysfs-class-switchtec
F:	Documentation/driver-api/switchtec.rst
F:	drivers/ntb/hw/mscc/
F:	drivers/pci/switch/switchtec*
F:	include/linux/switchtec.h
F:	include/uapi/linux/switchtec_ioctl.h

PCI DRIVER FOR MOBIVEIL PCIE IP
M:	Karthikeyan Mitran <m.karthikeyan@mobiveil.co.in>
M:	Hou Zhiqiang <Zhiqiang.Hou@nxp.com>
L:	linux-pci@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/pci/mobiveil-pcie.txt
F:	drivers/pci/controller/mobiveil/pcie-mobiveil*

PCI DRIVER FOR MVEBU (Marvell Armada 370 and Armada XP SOC support)
M:	Thomas Petazzoni <thomas.petazzoni@bootlin.com>
M:	Pali Rohár <pali@kernel.org>
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 NXP LAYERSCAPE GEN4 CONTROLLER
M:	Hou Zhiqiang <Zhiqiang.Hou@nxp.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/layerscape-pcie-gen4.txt
F:	drivers/pci/controller/mobiveil/pcie-layerscape-gen4.c

PCI DRIVER FOR RENESAS R-CAR
M:	Marek Vasut <marek.vasut+renesas@gmail.com>
M:	Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
L:	linux-pci@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/*rcar*
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
S:	Maintained
F:	drivers/pci/controller/dwc/pci-exynos.c

PCI DRIVER FOR SYNOPSYS DESIGNWARE
M:	Jingoo Han <jingoohan1@gmail.com>
M:	Gustavo Pimentel <gustavo.pimentel@synopsys.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/snps,dw-pcie.yaml
F:	Documentation/devicetree/bindings/pci/snps,dw-pcie-ep.yaml
F:	drivers/pci/controller/dwc/*designware*

PCI DRIVER FOR TI DRA7XX/J721E
M:	Kishon Vijay Abraham I <kishon@ti.com>
L:	linux-omap@vger.kernel.org
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/pci/ti-pci.txt
F:	drivers/pci/controller/cadence/pci-j721e.c
F:	drivers/pci/controller/dwc/pci-dra7xx.c

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

PCI ENDPOINT SUBSYSTEM
M:	Kishon Vijay Abraham I <kishon@ti.com>
M:	Lorenzo Pieralisi <lpieralisi@kernel.org>
R:	Krzysztof Wilczyński <kw@linux.com>
L:	linux-pci@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-pci/list/
B:	https://bugzilla.kernel.org
C:	irc://irc.oftc.net/linux-pci
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lpieralisi/pci.git
F:	Documentation/PCI/endpoint/*
F:	Documentation/misc-devices/pci-endpoint-test.rst
F:	drivers/misc/pci_endpoint_test.c
F:	drivers/pci/endpoint/
F:	tools/pci/

PCI ENHANCED ERROR HANDLING (EEH) FOR POWERPC
M:	Russell Currey <ruscur@russell.cc>
M:	Oliver O'Halloran <oohall@gmail.com>
L:	linuxppc-dev@lists.ozlabs.org
S:	Supported
F:	Documentation/PCI/pci-error-recovery.rst
F:	Documentation/powerpc/eeh-pci-error-recovery.rst
F:	arch/powerpc/include/*/eeh*.h
F:	arch/powerpc/kernel/eeh*.c
F:	arch/powerpc/platforms/*/eeh*.c
F:	drivers/pci/pcie/aer.c
F:	drivers/pci/pcie/dpc.c
F:	drivers/pci/pcie/err.c

PCI ERROR RECOVERY
M:	Linas Vepstas <linasvepstas@gmail.com>
L:	linux-pci@vger.kernel.org
S:	Supported
F:	Documentation/PCI/pci-error-recovery.rst

PCI PEER-TO-PEER DMA (P2PDMA)
M:	Bjorn Helgaas <bhelgaas@google.com>
M:	Logan Gunthorpe <logang@deltatee.com>
L:	linux-pci@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-pci/list/
B:	https://bugzilla.kernel.org
C:	irc://irc.oftc.net/linux-pci
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci.git
F:	Documentation/driver-api/pci/p2pdma.rst
F:	drivers/pci/p2pdma.c
F:	include/linux/pci-p2pdma.h

PCI MSI DRIVER FOR ALTERA MSI IP
M:	Joyce Ooi <joyce.ooi@intel.com>
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:	Toan Le <toan@os.amperecomputing.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/xgene-pci-msi.txt
F:	drivers/pci/controller/pci-xgene-msi.c

PCI NATIVE HOST BRIDGE AND ENDPOINT DRIVERS
M:	Lorenzo Pieralisi <lpieralisi@kernel.org>
R:	Rob Herring <robh@kernel.org>
R:	Krzysztof Wilczyński <kw@linux.com>
L:	linux-pci@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-pci/list/
B:	https://bugzilla.kernel.org
C:	irc://irc.oftc.net/linux-pci
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lpieralisi/pci.git
F:	drivers/pci/controller/
F:	drivers/pci/pci-bridge-emul.c
F:	drivers/pci/pci-bridge-emul.h

PCI SUBSYSTEM
M:	Bjorn Helgaas <bhelgaas@google.com>
L:	linux-pci@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-pci/list/
B:	https://bugzilla.kernel.org
C:	irc://irc.oftc.net/linux-pci
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci.git
F:	Documentation/PCI/
F:	Documentation/devicetree/bindings/pci/
F:	arch/x86/kernel/early-quirks.c
F:	arch/x86/kernel/quirks.c
F:	arch/x86/pci/
F:	drivers/acpi/pci*
F:	drivers/pci/
F:	include/asm-generic/pci*
F:	include/linux/of_pci.h
F:	include/linux/pci*
F:	include/uapi/linux/pci*
F:	lib/pci*

PCIE DRIVER FOR AMAZON ANNAPURNA LABS
M:	Jonathan Chocron <jonnyc@amazon.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/pcie-al.txt
F:	drivers/pci/controller/dwc/pcie-al.c

PCIE DRIVER FOR AMLOGIC MESON
M:	Yue Wang <yue.wang@Amlogic.com>
L:	linux-pci@vger.kernel.org
L:	linux-amlogic@lists.infradead.org
S:	Maintained
F:	drivers/pci/controller/dwc/pci-meson.c

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:	Robert Richter <rric@kernel.org>
L:	linux-pci@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Odd Fixes
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:	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/hisilicon,kirin-pcie.yaml
F:	drivers/pci/controller/dwc/pcie-kirin.c

PCIE DRIVER FOR HISILICON STB
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 INTEL KEEM BAY
M:	Srikanth Thokala <srikanth.thokala@intel.com>
L:	linux-pci@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/pci/intel,keembay-pcie*
F:	drivers/pci/controller/dwc/pcie-keembay.c

PCIE DRIVER FOR INTEL LGM GW SOC
M:	Rahul Tanwar <rtanwar@maxlinear.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/intel-gw-pcie.yaml
F:	drivers/pci/controller/dwc/pcie-intel-gw.c

PCIE DRIVER FOR MEDIATEK
M:	Ryder Lee <ryder.lee@mediatek.com>
M:	Jianjun Wang <jianjun.wang@mediatek.com>
L:	linux-pci@vger.kernel.org
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/pci/mediatek*
F:	drivers/pci/controller/*mediatek*

PCIE DRIVER FOR MICROCHIP
M:	Daire McNamara <daire.mcnamara@microchip.com>
L:	linux-pci@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/pci/microchip*
F:	drivers/pci/controller/*microchip*

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/pcie-qcom.c

PCIE ENDPOINT DRIVER FOR QUALCOMM
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
L:	linux-pci@vger.kernel.org
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/qcom,pcie-ep.yaml
F:	drivers/pci/controller/dwc/pcie-qcom-ep.c

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*

PCIE DRIVER FOR SOCIONEXT UNIPHIER
M:	Kunihiko Hayashi <hayashi.kunihiko@socionext.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/socionext,uniphier-pcie*
F:	drivers/pci/controller/dwc/pcie-uniphier*

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*

PCI DRIVER FOR XILINX VERSAL CPM
M:	Bharat Kumar Gogada <bharat.kumar.gogada@amd.com>
M:	Michal Simek <michal.simek@amd.com>
L:	linux-pci@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pci/xilinx-versal-cpm.yaml
F:	drivers/pci/controller/pcie-xilinx-cpm.c

PCMCIA SUBSYSTEM
M:	Dominik Brodowski <linux@dominikbrodowski.net>
S:	Odd Fixes
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/brodo/linux.git
F:	Documentation/pcmcia/
F:	drivers/pcmcia/
F:	include/pcmcia/
F:	tools/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

PECI HARDWARE MONITORING DRIVERS
M:	Iwona Winiarska <iwona.winiarska@intel.com>
L:	linux-hwmon@vger.kernel.org
S:	Supported
F:	Documentation/hwmon/peci-cputemp.rst
F:	Documentation/hwmon/peci-dimmtemp.rst
F:	drivers/hwmon/peci/

PECI SUBSYSTEM
M:	Iwona Winiarska <iwona.winiarska@intel.com>
L:	openbmc@lists.ozlabs.org (moderated for non-subscribers)
S:	Supported
F:	Documentation/devicetree/bindings/peci/
F:	Documentation/peci/
F:	drivers/peci/
F:	include/linux/peci-cpu.h
F:	include/linux/peci.h

PENSANDO ETHERNET DRIVERS
M:	Shannon Nelson <snelson@pensando.io>
M:	drivers@pensando.io
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/device_drivers/ethernet/pensando/ionic.rst
F:	drivers/net/ethernet/pensando/

PER-CPU MEMORY ALLOCATOR
M:	Dennis Zhou <dennis@kernel.org>
M:	Tejun Heo <tj@kernel.org>
M:	Christoph Lameter <cl@linux.com>
L:	linux-mm@kvack.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dennis/percpu.git
F:	arch/*/include/asm/percpu.h
F:	include/linux/percpu*.h
F:	lib/percpu*.c
F:	mm/percpu*.c

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:	Mark Rutland <mark.rutland@arm.com>
R:	Alexander Shishkin <alexander.shishkin@linux.intel.com>
R:	Jiri Olsa <jolsa@kernel.org>
R:	Namhyung Kim <namhyung@kernel.org>
L:	linux-perf-users@vger.kernel.org
L:	linux-kernel@vger.kernel.org
S:	Supported
W:	https://perf.wiki.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git perf/core
F:	arch/*/events/*
F:	arch/*/events/*/*
F:	arch/*/include/asm/perf_event.h
F:	arch/*/kernel/*/*/perf_event*.c
F:	arch/*/kernel/*/perf_event*.c
F:	arch/*/kernel/perf_callchain.c
F:	arch/*/kernel/perf_event*.c
F:	include/linux/perf_event.h
F:	include/uapi/linux/perf_event.h
F:	kernel/events/*
F:	tools/lib/perf/
F:	tools/perf/

PERFORMANCE EVENTS TOOLING ARM64
R:	John Garry <john.garry@huawei.com>
R:	Will Deacon <will@kernel.org>
R:	James Clark <james.clark@arm.com>
R:	Mike Leach <mike.leach@linaro.org>
R:	Leo Yan <leo.yan@linaro.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
F:	tools/build/feature/test-libopencsd.c
F:	tools/perf/arch/arm*/
F:	tools/perf/pmu-events/arch/arm64/
F:	tools/perf/util/arm-spe*
F:	tools/perf/util/cs-etm*

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

PHOENIX RC FLIGHT CONTROLLER ADAPTER
M:	Marcus Folkesson <marcus.folkesson@gmail.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	Documentation/input/devices/pxrc.rst
F:	drivers/input/joystick/pxrc.c

PHONET PROTOCOL
M:	Remi Denis-Courmont <courmisch@gmail.com>
S:	Supported
F:	Documentation/networking/phonet.rst
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*

PIDFD API
M:	Christian Brauner <christian@brauner.io>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/brauner/linux.git
F:	samples/pidfd/
F:	tools/testing/selftests/clone3/
F:	tools/testing/selftests/pid_namespace/
F:	tools/testing/selftests/pidfd/
K:	(?i)pidfd
K:	(?i)clone3
K:	\b(clone_args|kernel_clone_args)\b

PIN CONTROL SUBSYSTEM
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-gpio@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-pinctrl.git
F:	Documentation/devicetree/bindings/pinctrl/
F:	Documentation/driver-api/pin-control.rst
F:	drivers/pinctrl/
F:	include/linux/pinctrl/

PIN CONTROLLER - AMD
M:	Basavaraj Natikar <Basavaraj.Natikar@amd.com>
M:	Shyam Sundar S K <Shyam-sundar.S-k@amd.com>
S:	Maintained
F:	drivers/pinctrl/pinctrl-amd.c

PIN CONTROLLER - FREESCALE
M:	Dong Aisheng <aisheng.dong@nxp.com>
M:	Fabio Estevam <festevam@gmail.com>
M:	Shawn Guo <shawnguo@kernel.org>
M:	Jacky Bai <ping.bai@nxp.com>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pinctrl/fsl,*
F:	drivers/pinctrl/freescale/

PIN CONTROLLER - INTEL
M:	Mika Westerberg <mika.westerberg@linux.intel.com>
M:	Andy Shevchenko <andy@kernel.org>
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pinctrl/intel.git
F:	drivers/pinctrl/intel/

PIN CONTROLLER - KEEMBAY
M:	Lakshmi Sowjanya D <lakshmi.sowjanya.d@intel.com>
S:	Supported
F:	drivers/pinctrl/pinctrl-keembay*

PIN CONTROLLER - MEDIATEK
M:	Sean Wang <sean.wang@kernel.org>
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/pinctrl/mediatek,mt65xx-pinctrl.yaml
F:	Documentation/devicetree/bindings/pinctrl/mediatek,mt6797-pinctrl.yaml
F:	Documentation/devicetree/bindings/pinctrl/mediatek,mt7622-pinctrl.yaml
F:	Documentation/devicetree/bindings/pinctrl/mediatek,mt8183-pinctrl.yaml
F:	drivers/pinctrl/mediatek/

PIN CONTROLLER - MICROCHIP AT91
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/gpio/gpio-sama5d2-piobu.c
F:	drivers/pinctrl/pinctrl-at91*

PIN CONTROLLER - QUALCOMM
M:	Bjorn Andersson <bjorn.andersson@linaro.org>
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pinctrl/qcom,*.txt
F:	drivers/pinctrl/qcom/

PIN CONTROLLER - RENESAS
M:	Geert Uytterhoeven <geert+renesas@glider.be>
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-drivers.git renesas-pinctrl
F:	Documentation/devicetree/bindings/pinctrl/renesas,*
F:	drivers/pinctrl/renesas/

PIN CONTROLLER - SAMSUNG
M:	Tomasz Figa <tomasz.figa@gmail.com>
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
R:	Alim Akhtar <alim.akhtar@samsung.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
C:	irc://irc.libera.chat/linux-exynos
Q:	https://patchwork.kernel.org/project/linux-samsung-soc/list/
B:	mailto:linux-samsung-soc@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pinctrl/samsung.git
F:	Documentation/devicetree/bindings/pinctrl/samsung,pinctrl*yaml
F:	drivers/pinctrl/samsung/
F:	include/dt-bindings/pinctrl/samsung.h

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 - THUNDERBAY
M:	Lakshmi Sowjanya D <lakshmi.sowjanya.d@intel.com>
S:	Supported
F:	drivers/pinctrl/pinctrl-thunderbay.c

PIN CONTROLLER - SUNPLUS / TIBBO
M:	Dvorkin Dmitry <dvorkin@tibbo.com>
M:	Wells Lu <wellslutw@gmail.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
W:	https://sunplus.atlassian.net/wiki/spaces/doc/overview
F:	Documentation/devicetree/bindings/pinctrl/sunplus,*
F:	drivers/pinctrl/sunplus/
F:	include/dt-bindings/pinctrl/sppctl*.h

PKTCDVD DRIVER
M:	linux-block@vger.kernel.org
S:	Orphan
F:	drivers/block/pktcdvd.c
F:	include/linux/pktcdvd.h
F:	include/uapi/linux/pktcdvd.h

PLANTOWER PMS7003 AIR POLLUTION SENSOR DRIVER
M:	Tomasz Duszynski <tduszyns@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/iio/chemical/plantower,pms7003.yaml
F:	drivers/iio/chemical/pms7003.c

PLDMFW LIBRARY
M:	Jacob Keller <jacob.e.keller@intel.com>
S:	Maintained
F:	Documentation/driver-api/pldmfw/
F:	include/linux/pldmfw.h
F:	lib/pldmfw/

PLX DMA DRIVER
M:	Logan Gunthorpe <logang@deltatee.com>
S:	Maintained
F:	drivers/dma/plx_dma.c

PM6764TR DRIVER
M:	Charles Hsu	<hsu.yungteng@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/pm6764tr.rst
F:	drivers/hwmon/pmbus/pm6764tr.c

PM-GRAPH UTILITY
M:	"Todd E Brandt" <todd.e.brandt@linux.intel.com>
L:	linux-pm@vger.kernel.org
S:	Supported
W:	https://01.org/pm-graph
B:	https://bugzilla.kernel.org/buglist.cgi?component=pm-graph&product=Tools
T:	git git://github.com/intel/pm-graph
F:	tools/power/pm-graph

PMBUS HARDWARE MONITORING DRIVERS
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
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
F:	Documentation/devicetree/bindings/hwmon/ltc2978.txt
F:	Documentation/devicetree/bindings/hwmon/max31785.txt
F:	Documentation/hwmon/adm1275.rst
F:	Documentation/hwmon/ibm-cffps.rst
F:	Documentation/hwmon/ir35221.rst
F:	Documentation/hwmon/lm25066.rst
F:	Documentation/hwmon/ltc2978.rst
F:	Documentation/hwmon/ltc3815.rst
F:	Documentation/hwmon/max16064.rst
F:	Documentation/hwmon/max20751.rst
F:	Documentation/hwmon/max31785.rst
F:	Documentation/hwmon/max34440.rst
F:	Documentation/hwmon/max8688.rst
F:	Documentation/hwmon/pmbus-core.rst
F:	Documentation/hwmon/pmbus.rst
F:	Documentation/hwmon/tps40422.rst
F:	Documentation/hwmon/ucd9000.rst
F:	Documentation/hwmon/ucd9200.rst
F:	Documentation/hwmon/zl6100.rst
F:	drivers/hwmon/pmbus/
F:	include/linux/pmbus.h

PMC SIERRA MaxRAID DRIVER
L:	linux-scsi@vger.kernel.org
S:	Orphan
W:	http://www.pmc-sierra.com/
F:	drivers/scsi/pmcraid.*

PMC SIERRA PM8001 DRIVER
M:	Jack Wang <jinpu.wang@cloud.ionos.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/pm8001/

PNI RM3100 IIO DRIVER
M:	Song Qiang <songqiang1304521@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/magnetometer/pni,rm3100.yaml
F:	drivers/iio/magnetometer/rm3100*

PNP SUPPORT
M:	"Rafael J. Wysocki" <rafael.j.wysocki@intel.com>
L:	linux-acpi@vger.kernel.org
S:	Maintained
F:	drivers/pnp/
F:	include/linux/pnp.h

POSIX CLOCKS and TIMERS
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 timers/core
F:	fs/timerfd.c
F:	include/linux/time_namespace.h
F:	include/linux/timer*
F:	kernel/time/*timer*
F:	kernel/time/namespace.c

POWER MANAGEMENT CORE
M:	"Rafael J. Wysocki" <rafael@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Supported
B:	https://bugzilla.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
F:	drivers/base/power/
F:	drivers/powercap/
F:	include/linux/intel_rapl.h
F:	include/linux/pm.h
F:	include/linux/pm_*
F:	include/linux/powercap.h
F:	kernel/configs/nopm.config

DYNAMIC THERMAL POWER MANAGEMENT (DTPM)
M:	Daniel Lezcano <daniel.lezcano@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Supported
B:	https://bugzilla.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
F:	drivers/powercap/dtpm*
F:	include/linux/dtpm.h

POWER STATE COORDINATION INTERFACE (PSCI)
M:	Mark Rutland <mark.rutland@arm.com>
M:	Lorenzo Pieralisi <lpieralisi@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/firmware/psci/
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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-power-supply.git
F:	Documentation/ABI/testing/sysfs-class-power
F:	Documentation/devicetree/bindings/power/supply/
F:	drivers/power/supply/
F:	include/linux/power/
F:	include/linux/power_supply.h

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:	include/uapi/linux/atmppp.h
F:	net/atm/pppoatm.c

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:	include/linux/if_pppol2tp.h
F:	include/uapi/linux/if_pppol2tp.h
F:	net/l2tp/l2tp_ppp.c

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>
L:	linuxpps@ml.enneenne.com (subscribers-only)
S:	Maintained
W:	http://wiki.enneenne.com/index.php/LinuxPPS_support
F:	Documentation/ABI/testing/sysfs-pps
F:	Documentation/devicetree/bindings/pps/pps-gpio.txt
F:	Documentation/driver-api/pps.rst
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
W:	http://sourceforge.net/projects/accel-pptp
F:	drivers/net/ppp/pptp.c

PRESSURE STALL INFORMATION (PSI)
M:	Johannes Weiner <hannes@cmpxchg.org>
M:	Suren Baghdasaryan <surenb@google.com>
S:	Maintained
F:	include/linux/psi*
F:	kernel/sched/psi.c

PRINTK
M:	Petr Mladek <pmladek@suse.com>
M:	Sergey Senozhatsky <senozhatsky@chromium.org>
R:	Steven Rostedt <rostedt@goodmis.org>
R:	John Ogness <john.ogness@linutronix.de>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/printk/linux.git
F:	include/linux/printk.h
F:	kernel/printk/

PRINTK INDEXING
R:	Chris Down <chris@chrisdown.name>
S:	Maintained
F:	Documentation/core-api/printk-index.rst
F:	kernel/printk/index.c
K:	printk_index

PROC FILESYSTEM
L:	linux-kernel@vger.kernel.org
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	Documentation/filesystems/proc.rst
F:	fs/proc/
F:	include/linux/proc_fs.h
F:	tools/testing/selftests/proc/

PROC SYSCTL
M:	Luis Chamberlain <mcgrof@kernel.org>
M:	Kees Cook <keescook@chromium.org>
M:	Iurii Zaikin <yzaikin@google.com>
L:	linux-kernel@vger.kernel.org
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mcgrof/linux.git sysctl-next
F:	fs/proc/proc_sysctl.c
F:	include/linux/sysctl.h
F:	kernel/sysctl-test.c
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:	include/net/psample.h
F:	include/uapi/linux/psample.h
F:	net/psample

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:	Documentation/admin-guide/ramoops.rst
F:	Documentation/admin-guide/pstore-blk.rst
F:	Documentation/devicetree/bindings/reserved-memory/ramoops.yaml
F:	drivers/acpi/apei/erst.c
F:	drivers/firmware/efi/efi-pstore.c
F:	fs/pstore/
F:	include/linux/pstore*
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/driver-api/ptp.rst
F:	drivers/net/phy/dp83640*
F:	drivers/ptp/*
F:	include/linux/ptp_cl*

PTP VIRTUAL CLOCK SUPPORT
M:	Yangbo Lu <yangbo.lu@nxp.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/ptp/ptp_vclock.c
F:	net/ethtool/phc_vclocks.c

PTRACE SUPPORT
M:	Oleg Nesterov <oleg@redhat.com>
S:	Maintained
F:	arch/*/*/ptrace*.c
F:	arch/*/include/asm/ptrace*.h
F:	arch/*/ptrace*.c
F:	include/asm-generic/syscall.h
F:	include/linux/ptrace.h
F:	include/linux/regset.h
F:	include/uapi/linux/ptrace.h
F:	kernel/ptrace.c

PULSE8-CEC DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/admin-guide/media/pulse8-cec.rst
F:	drivers/media/cec/usb/pulse8/

PURELIFI PLFXLC DRIVER
M:	Srinivasan Raju <srini.raju@purelifi.com>
L:	linux-wireless@vger.kernel.org
S:	Supported
F:	drivers/net/wireless/purelifi/plfxlc/

PVRUSB2 VIDEO4LINUX DRIVER
M:	Mike Isely <isely@pobox.com>
L:	pvrusb2@isely.net	(subscribers-only)
L:	linux-media@vger.kernel.org
S:	Maintained
W:	http://www.isely.net/pvrusb2/
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/driver-api/media/drivers/pvrusb2*
F:	drivers/media/usb/pvrusb2/

PWC WEBCAM DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/usb/pwc/*
F:	include/trace/events/pwc.h

PWM FAN DRIVER
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.rst
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>
R:	Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
L:	linux-pwm@vger.kernel.org
S:	Maintained
Q:	https://patchwork.ozlabs.org/project/linux-pwm/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/thierry.reding/linux-pwm.git
F:	Documentation/devicetree/bindings/gpio/gpio-mvebu.yaml
F:	Documentation/devicetree/bindings/pwm/
F:	Documentation/driver-api/pwm.rst
F:	drivers/gpio/gpio-mvebu.c
F:	drivers/pwm/
F:	drivers/video/backlight/pwm_bl.c
F:	include/dt-bindings/pwm/
F:	include/linux/pwm.h
F:	include/linux/pwm_backlight.h
K:	pwm_(config|apply_state|ops)

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)
S:	Maintained
T:	git git://github.com/hzhuang1/linux.git
T:	git git://github.com/rjarzmik/linux.git
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:	Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
M:	Banajit Goswami <bgoswami@quicinc.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
F:	sound/soc/codecs/lpass-va-macro.c
F:	sound/soc/codecs/lpass-wsa-macro.*
F:	sound/soc/codecs/msm8916-wcd-analog.c
F:	sound/soc/codecs/msm8916-wcd-digital.c
F:	sound/soc/codecs/wcd9335.*
F:	sound/soc/codecs/wcd934x.c
F:	sound/soc/codecs/wcd-clsh-v2.*
F:	sound/soc/codecs/wsa881x.c
F:	sound/soc/qcom/

QCOM EMBEDDED USB DEBUGGER (EUD)
M:	Souradeep Chowdhury <quic_schowdhu@quicinc.com>
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-driver-eud
F:	Documentation/devicetree/bindings/soc/qcom/qcom,eud.yaml
F:	drivers/usb/misc/qcom_eud.c

QCOM IPA DRIVER
M:	Alex Elder <elder@kernel.org>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ipa/

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@cornelisnetworks.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
F:	drivers/infiniband/hw/qib/

QLOGIC QL41xxx FCOE DRIVER
M:	Saurav Kashyap <skashyap@marvell.com>
M:	Javed Hasan <jhasan@marvell.com>
M:	GR-QLogic-Storage-Upstream@marvell.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/qedf/

QLOGIC QL41xxx ISCSI DRIVER
M:	Nilesh Javali <njavali@marvell.com>
M:	Manish Rangankar <mrangankar@marvell.com>
M:	GR-QLogic-Storage-Upstream@marvell.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/qedi/

QLOGIC QL4xxx ETHERNET DRIVER
M:	Ariel Elior <aelior@marvell.com>
M:	Manish Chopra <manishc@marvell.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/qlogic/qed/
F:	drivers/net/ethernet/qlogic/qede/
F:	include/linux/qed/

QLOGIC QL4xxx RDMA DRIVER
M:	Michal Kalderon <mkalderon@marvell.com>
M:	Ariel Elior <aelior@marvell.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:	Nilesh Javali <njavali@marvell.com>
M:	GR-QLogic-Storage-Upstream@marvell.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/qla2xxx/

QLOGIC QLA3XXX NETWORK DRIVER
M:	GR-Linux-NIC-Dev@marvell.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/qlogic/qla3xxx.*

QLOGIC QLA4XXX iSCSI DRIVER
M:	Nilesh Javali <njavali@marvell.com>
M:	Manish Rangankar <mrangankar@marvell.com>
M:	GR-QLogic-Storage-Upstream@marvell.com
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/scsi/qla4xxx/

QLOGIC QLCNIC (1/10)Gb ETHERNET DRIVER
M:	Shahed Shaikh <shshaikh@marvell.com>
M:	Manish Chopra <manishc@marvell.com>
M:	GR-Linux-NIC-Dev@marvell.com
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/qlogic/qlcnic/

QLOGIC QLGE 10Gb ETHERNET DRIVER
M:	Manish Chopra <manishc@marvell.com>
M:	GR-Linux-NIC-Dev@marvell.com
M:	Coiby Xu <coiby.xu@gmail.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	Documentation/networking/device_drivers/qlogic/qlge.rst
F:	drivers/staging/qlge/

QM1D1B0004 MEDIA DRIVER
M:	Akihiro Tsukada <tskd08@gmail.com>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
F:	drivers/media/tuners/qm1d1b0004*

QM1D1C0042 MEDIA DRIVER
M:	Akihiro Tsukada <tskd08@gmail.com>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
F:	drivers/media/tuners/qm1d1c0042*

QNX4 FILESYSTEM
M:	Anders Larsen <al@alarsen.net>
S:	Maintained
W:	http://www.alarsen.net/linux/qnx4fs/
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:	Documentation/ABI/stable/sysfs-bus-fsl-mc
F:	Documentation/devicetree/bindings/misc/fsl,qoriq-mc.txt
F:	Documentation/networking/device_drivers/ethernet/freescale/dpaa2/overview.rst
F:	drivers/bus/fsl-mc/
F:	include/uapi/linux/fsl_mc.h

QT1010 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/tuners/qt1010*

QUALCOMM ATHEROS ATH10K WIRELESS DRIVER
M:	Kalle Valo <kvalo@kernel.org>
L:	ath10k@lists.infradead.org
S:	Supported
W:	https://wireless.wiki.kernel.org/en/users/Drivers/ath10k
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git
F:	drivers/net/wireless/ath/ath10k/
F:	Documentation/devicetree/bindings/net/wireless/qcom,ath10k.txt

QUALCOMM ATHEROS ATH11K WIRELESS DRIVER
M:	Kalle Valo <kvalo@kernel.org>
L:	ath11k@lists.infradead.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kvalo/ath.git
F:	Documentation/devicetree/bindings/net/wireless/qcom,ath11k.yaml
F:	drivers/net/wireless/ath/ath11k/

QUALCOMM ATHEROS ATH9K WIRELESS DRIVER
M:	Toke Høiland-Jørgensen <toke@toke.dk>
L:	linux-wireless@vger.kernel.org
S:	Maintained
W:	https://wireless.wiki.kernel.org/en/users/Drivers/ath9k
F:	Documentation/devicetree/bindings/net/wireless/qca,ath9k.yaml
F:	drivers/net/wireless/ath/ath9k/

QUALCOMM BAM-DMUX WWAN NETWORK DRIVER
M:	Stephan Gerhold <stephan@gerhold.net>
L:	netdev@vger.kernel.org
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/qcom,bam-dmux.yaml
F:	drivers/net/wwan/qcom_bam_dmux.c

QUALCOMM CAMERA SUBSYSTEM DRIVER
M:	Robert Foss <robert.foss@linaro.org>
M:	Todor Tomov <todor.too@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/admin-guide/media/qcom_camss.rst
F:	Documentation/devicetree/bindings/media/*camss*
F:	drivers/media/platform/qcom/camss/

QUALCOMM CLOCK DRIVERS
M:	Bjorn Andersson <bjorn.andersson@linaro.org>
L:	linux-arm-msm@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/qcom/linux.git
F:	Documentation/devicetree/bindings/clock/qcom,*
F:	drivers/clk/qcom/
F:	include/dt-bindings/clock/qcom,*

QUALCOMM CORE POWER REDUCTION (CPR) AVS DRIVER
M:	Niklas Cassel <nks@flawful.org>
L:	linux-pm@vger.kernel.org
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/power/avs/qcom,cpr.yaml
F:	drivers/soc/qcom/cpr.c

QUALCOMM CPUFREQ DRIVER MSM8996/APQ8096
M:	Ilia Lin <ilia.lin@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/cpufreq/qcom-cpufreq-nvmem.yaml
F:	Documentation/devicetree/bindings/opp/opp-v2-kryo-cpu.yaml
F:	drivers/cpufreq/qcom-cpufreq-nvmem.c

QUALCOMM CRYPTO DRIVERS
M:	Thara Gopinath <thara.gopinath@gmail.com>
L:	linux-crypto@vger.kernel.org
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	drivers/crypto/qce/

QUALCOMM EMAC GIGABIT ETHERNET DRIVER
M:	Timur Tabi <timur@kernel.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/qualcomm/emac/

QUALCOMM ETHQOS ETHERNET DRIVER
M:	Vinod Koul <vkoul@kernel.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/qcom,ethqos.txt
F:	drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c

QUALCOMM FASTRPC DRIVER
M:	Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
M:	Amol Maheshwari <amahesh@qti.qualcomm.com>
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/misc/qcom,fastrpc.txt
F:	drivers/misc/fastrpc.c
F:	include/uapi/misc/fastrpc.h

QUALCOMM HEXAGON ARCHITECTURE
M:	Brian Cain <bcain@quicinc.com>
L:	linux-hexagon@vger.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/bcain/linux.git
S:	Supported
F:	arch/hexagon/

QUALCOMM HIDMA DRIVER
M:	Sinan Kaya <okaya@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
L:	linux-arm-msm@vger.kernel.org
L:	dmaengine@vger.kernel.org
S:	Supported
F:	drivers/dma/qcom/hidma*

QUALCOMM I2C CCI DRIVER
M:	Loic Poulain <loic.poulain@linaro.org>
M:	Robert Foss <robert.foss@linaro.org>
L:	linux-i2c@vger.kernel.org
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-qcom-cci.txt
F:	drivers/i2c/busses/i2c-qcom-cci.c

QUALCOMM INTERCONNECT BWMON DRIVER
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/interconnect/qcom,msm8998-bwmon.yaml
F:	drivers/soc/qcom/icc-bwmon.c

QUALCOMM IOMMU
M:	Rob Clark <robdclark@gmail.com>
L:	iommu@lists.linux.dev
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	drivers/iommu/arm/arm-smmu/qcom_iommu.c

QUALCOMM IPC ROUTER (QRTR) DRIVER
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	include/trace/events/qrtr.h
F:	include/uapi/linux/qrtr.h
F:	net/qrtr/

QUALCOMM IPCC MAILBOX DRIVER
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
L:	linux-arm-msm@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/mailbox/qcom-ipcc.yaml
F:	drivers/mailbox/qcom-ipcc.c
F:	include/dt-bindings/mailbox/qcom-ipcc.h

QUALCOMM IPQ4019 USB PHY DRIVER
M:	Robert Marko <robert.marko@sartura.hr>
M:	Luka Perkov <luka.perkov@sartura.hr>
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/phy/qcom-usb-ipq4019-phy.yaml
F:	drivers/phy/qualcomm/phy-qcom-ipq4019-usb.c

QUALCOMM IPQ4019 VQMMC REGULATOR DRIVER
M:	Robert Marko <robert.marko@sartura.hr>
M:	Luka Perkov <luka.perkov@sartura.hr>
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/regulator/vqmmc-ipq4019-regulator.yaml
F:	drivers/regulator/vqmmc-ipq4019-regulator.c

QUALCOMM NAND CONTROLLER DRIVER
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
L:	linux-mtd@lists.infradead.org
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/mtd/qcom,nandc.yaml
F:	drivers/mtd/nand/raw/qcom_nandc.c

QUALCOMM RMNET DRIVER
M:	Subash Abhinov Kasiviswanathan <quic_subashab@quicinc.com>
M:	Sean Tranchetti <quic_stranche@quicinc.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/networking/device_drivers/cellular/qualcomm/rmnet.rst
F:	drivers/net/ethernet/qualcomm/rmnet/
F:	include/linux/if_rmnet.h

QUALCOMM TSENS THERMAL DRIVER
M:	Amit Kucheria <amitk@kernel.org>
M:	Thara Gopinath <thara.gopinath@gmail.com>
L:	linux-pm@vger.kernel.org
L:	linux-arm-msm@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/thermal/qcom-tsens.yaml
F:	drivers/thermal/qcom/

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
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/*venus*
F:	drivers/media/platform/qcom/venus/

QUALCOMM WCN36XX WIRELESS DRIVER
M:	Loic Poulain <loic.poulain@linaro.org>
L:	wcn36xx@lists.infradead.org
S:	Supported
W:	https://wireless.wiki.kernel.org/en/users/Drivers/wcn36xx
F:	drivers/net/wireless/ath/wcn36xx/

QUANTENNA QTNFMAC WIRELESS DRIVER
M:	Igor Mitsyanko <imitsyanko@quantenna.com>
R:	Sergey Matyukevich <geomatsi@gmail.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:	Pan, Xinhui <Xinhui.Pan@amd.com>
L:	amd-gfx@lists.freedesktop.org
S:	Supported
T:	git https://gitlab.freedesktop.org/agd5f/linux.git
B:	https://gitlab.freedesktop.org/drm/amd/-/issues
C:	irc://irc.oftc.net/radeon
F:	Documentation/gpu/amdgpu/
F:	drivers/gpu/drm/amd/
F:	drivers/gpu/drm/radeon/
F:	include/uapi/drm/amdgpu_drm.h
F:	include/uapi/drm/radeon_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
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/radio/radio-shark.c

RADIOSHARK2 RADIO DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/radio/radio-shark2.c
F:	drivers/media/radio/radio-tea5777.c

RADOS BLOCK DEVICE (RBD)
M:	Ilya Dryomov <idryomov@gmail.com>
R:	Dongsheng Yang <dongsheng.yang@easystack.cn>
L:	ceph-devel@vger.kernel.org
S:	Supported
W:	http://ceph.com/
T:	git git://github.com/ceph/ceph-client.git
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
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/cec/usb/rainshadow/

RALINK MIPS ARCHITECTURE
M:	John Crispin <john@phrozen.org>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	arch/mips/ralink

RALINK MT7621 MIPS ARCHITECTURE
M:	Arınç ÜNAL <arinc.unal@arinc9.com>
M:	Sergio Paracuellos <sergio.paracuellos@gmail.com>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	arch/mips/boot/dts/ralink/mt7621*

RALINK PINCTRL DRIVER
M:	Arınç ÜNAL <arinc.unal@arinc9.com>
M:	Sergio Paracuellos <sergio.paracuellos@gmail.com>
L:	linux-mips@vger.kernel.org
S:	Maintained
F:	drivers/pinctrl/ralink/

RALINK RT2X00 WIRELESS LAN DRIVER
M:	Stanislaw Gruszka <stf_xl@wp.pl>
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/admin-guide/blockdev/ramdisk.rst
F:	drivers/block/brd.c

RANCHU VIRTUAL BOARD FOR MIPS
M:	Miodrag Dinic <miodrag.dinic@mips.com>
L:	linux-mips@vger.kernel.org
S:	Supported
F:	arch/mips/configs/generic/board-ranchu.config
F:	arch/mips/generic/board-ranchu.c

RANDOM NUMBER DRIVER
M:	"Theodore Ts'o" <tytso@mit.edu>
M:	Jason A. Donenfeld <Jason@zx2c4.com>
T:	git https://git.kernel.org/pub/scm/linux/kernel/git/crng/random.git
S:	Maintained
F:	drivers/char/random.c
F:	drivers/virt/vmgenid.c

RAPIDIO SUBSYSTEM
M:	Matt Porter <mporter@kernel.crashing.org>
M:	Alexandre Bounine <alex.bou9@gmail.com>
S:	Maintained
F:	drivers/rapidio/

RAS INFRASTRUCTURE
M:	Tony Luck <tony.luck@intel.com>
M:	Borislav Petkov <bp@alien8.de>
L:	linux-edac@vger.kernel.org
S:	Maintained
F:	Documentation/admin-guide/ras.rst
F:	drivers/ras/
F:	include/linux/ras.h
F:	include/ras/ras_event.h

RAYLINK/WEBGEAR 802.11 WIRELESS LAN DRIVER
L:	linux-wireless@vger.kernel.org
S:	Orphan
F:	drivers/net/wireless/ray*

RC-CORE / LIRC FRAMEWORK
M:	Sean Young <sean@mess.org>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	http://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/driver-api/media/rc-core.rst
F:	Documentation/userspace-api/media/rc/
F:	drivers/media/rc/
F:	include/media/rc-map.h
F:	include/media/rc-core.h
F:	include/uapi/linux/lirc.h

RCMM REMOTE CONTROLS DECODER
M:	Patrick Lerda <patrick9876@free.fr>
S:	Maintained
F:	drivers/media/rc/ir-rcmm-decoder.c

RCUTORTURE TEST FRAMEWORK
M:	"Paul E. McKenney" <paulmck@kernel.org>
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:	rcu@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git dev
F:	tools/testing/selftests/rcutorture

RDACM20 Camera Sensor
M:	Jacopo Mondi <jacopo+renesas@jmondi.org>
M:	Kieran Bingham <kieran.bingham+renesas@ideasonboard.com>
M:	Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com>
M:	Niklas Söderlund <niklas.soderlund+renesas@ragnatech.se>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/i2c/imi,rdacm2x-gmsl.yaml
F:	drivers/media/i2c/max9271.c
F:	drivers/media/i2c/max9271.h
F:	drivers/media/i2c/rdacm20.c

RDACM21 Camera Sensor
M:	Jacopo Mondi <jacopo+renesas@jmondi.org>
M:	Kieran Bingham <kieran.bingham+renesas@ideasonboard.com>
M:	Laurent Pinchart <laurent.pinchart+renesas@ideasonboard.com>
M:	Niklas Söderlund <niklas.soderlund+renesas@ragnatech.se>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/i2c/imi,rdacm2x-gmsl.yaml
F:	drivers/media/i2c/max9271.c
F:	drivers/media/i2c/max9271.h
F:	drivers/media/i2c/rdacm21.c

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@cornelisnetworks.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)
S:	Supported
W:	https://oss.oracle.com/projects/rds/
F:	Documentation/networking/rds.rst
F:	net/rds/

RDT - RESOURCE ALLOCATION
M:	Fenghua Yu <fenghua.yu@intel.com>
M:	Reinette Chatre <reinette.chatre@intel.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	Documentation/x86/resctrl*
F:	arch/x86/include/asm/resctrl.h
F:	arch/x86/kernel/cpu/resctrl/
F:	tools/testing/selftests/resctrl/

READ-COPY UPDATE (RCU)
M:	"Paul E. McKenney" <paulmck@kernel.org>
M:	Frederic Weisbecker <frederic@kernel.org> (kernel/rcu/tree_nocb.h)
M:	Neeraj Upadhyay <quic_neeraju@quicinc.com> (kernel/rcu/tasks.h)
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>
R:	Joel Fernandes <joel@joelfernandes.org>
L:	rcu@vger.kernel.org
S:	Supported
W:	http://www.rdrop.com/users/paulmck/RCU/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git dev
F:	Documentation/RCU/
F:	include/linux/rcu*
F:	kernel/rcu/
X:	Documentation/RCU/torture.rst
X:	include/linux/srcu*.h
X:	kernel/rcu/srcu*.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
S:	Maintained
Q:	http://patchwork.ozlabs.org/project/rtc-linux/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux.git
F:	Documentation/admin-guide/rtc.rst
F:	Documentation/devicetree/bindings/rtc/
F:	drivers/rtc/
F:	include/linux/platform_data/rtc-*
F:	include/linux/rtc.h
F:	include/linux/rtc/
F:	include/uapi/linux/rtc.h
F:	tools/testing/selftests/rtc/

REALTEK AUDIO CODECS
M:	Oder Chiou <oder_chiou@realtek.com>
S:	Maintained
F:	include/sound/rt*.h
F:	sound/soc/codecs/rt*

REALTEK OTTO WATCHDOG
M:	Sander Vanheule <sander@svanheule.net>
L:	linux-watchdog@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/watchdog/realtek,otto-wdt.yaml
F:	drivers/watchdog/realtek_otto_wdt.c

REALTEK RTL83xx SMI DSA ROUTER CHIPS
M:	Linus Walleij <linus.walleij@linaro.org>
M:	Alvin Šipraga <alsi@bang-olufsen.dk>
S:	Maintained
F:	Documentation/devicetree/bindings/net/dsa/realtek.yaml
F:	drivers/net/dsa/realtek/*

REALTEK WIRELESS DRIVER (rtlwifi family)
M:	Ping-Ke Shih <pkshih@realtek.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
W:	https://wireless.wiki.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-testing.git
F:	drivers/net/wireless/realtek/rtlwifi/

REALTEK WIRELESS DRIVER (rtw88)
M:	Yan-Hsuan Chuang <tony0620emma@gmail.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/net/wireless/realtek/rtw88/

REALTEK WIRELESS DRIVER (rtw89)
M:	Ping-Ke Shih <pkshih@realtek.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/net/wireless/realtek/rtw89/

REDPINE WIRELESS DRIVER
M:	Amitkumar Karwar <amitkarwar@gmail.com>
M:	Siva Rebbagondla <siva8118@gmail.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
F:	drivers/net/wireless/rsi/

REGISTER MAP ABSTRACTION
M:	Mark Brown <broonie@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap.git
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:	Bjorn Andersson <bjorn.andersson@linaro.org>
M:	Mathieu Poirier <mathieu.poirier@linaro.org>
L:	linux-remoteproc@vger.kernel.org
S:	Maintained
T:	git https://git.kernel.org/pub/scm/linux/kernel/git/remoteproc/linux.git rproc-next
F:	Documentation/ABI/testing/sysfs-class-remoteproc
F:	Documentation/devicetree/bindings/remoteproc/
F:	Documentation/staging/remoteproc.rst
F:	drivers/remoteproc/
F:	include/linux/remoteproc.h
F:	include/linux/remoteproc/

REMOTE PROCESSOR MESSAGING (RPMSG) SUBSYSTEM
M:	Bjorn Andersson <bjorn.andersson@linaro.org>
M:	Mathieu Poirier <mathieu.poirier@linaro.org>
L:	linux-remoteproc@vger.kernel.org
S:	Maintained
T:	git https://git.kernel.org/pub/scm/linux/kernel/git/remoteproc/linux.git rpmsg-next
F:	Documentation/ABI/testing/sysfs-bus-rpmsg
F:	Documentation/staging/rpmsg.rst
F:	drivers/rpmsg/
F:	include/linux/rpmsg.h
F:	include/linux/rpmsg/
F:	include/uapi/linux/rpmsg.h
F:	samples/rpmsg/

REMOTE PROCESSOR MESSAGING (RPMSG) WWAN CONTROL DRIVER
M:	Stephan Gerhold <stephan@gerhold.net>
L:	netdev@vger.kernel.org
L:	linux-remoteproc@vger.kernel.org
S:	Maintained
F:	drivers/net/wwan/rpmsg_wwan_ctrl.c

RENESAS CLOCK DRIVERS
M:	Geert Uytterhoeven <geert+renesas@glider.be>
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/geert/renesas-drivers.git renesas-clk
F:	Documentation/devicetree/bindings/clock/renesas,*
F:	drivers/clk/renesas/

RENESAS EMEV2 I2C DRIVER
M:	Wolfram Sang <wsa+renesas@sang-engineering.com>
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/i2c/renesas,iic-emev2.yaml
F:	drivers/i2c/busses/i2c-emev2.c

RENESAS ETHERNET DRIVERS
R:	Sergey Shtylyov <s.shtylyov@omp.ru>
L:	netdev@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
F:	Documentation/devicetree/bindings/net/renesas,*.yaml
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:	Documentation/devicetree/bindings/iio/adc/renesas,rcar-gyroadc.yaml
F:	drivers/iio/adc/rcar-gyroadc.c

RENESAS R-CAR I2C DRIVERS
M:	Wolfram Sang <wsa+renesas@sang-engineering.com>
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/i2c/renesas,rcar-i2c.yaml
F:	Documentation/devicetree/bindings/i2c/renesas,rmobile-iic.yaml
F:	drivers/i2c/busses/i2c-rcar.c
F:	drivers/i2c/busses/i2c-sh_mobile.c

RENESAS R-CAR SATA DRIVER
R:	Sergey Shtylyov <s.shtylyov@omp.ru>
S:	Supported
L:	linux-ide@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
F:	Documentation/devicetree/bindings/ata/renesas,rcar-sata.yaml
F:	drivers/ata/sata_rcar.c

RENESAS R-CAR THERMAL DRIVERS
M:	Niklas Söderlund <niklas.soderlund@ragnatech.se>
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/thermal/rcar-gen3-thermal.yaml
F:	Documentation/devicetree/bindings/thermal/rcar-thermal.yaml
F:	drivers/thermal/rcar_gen3_thermal.c
F:	drivers/thermal/rcar_thermal.c

RENESAS RIIC DRIVER
M:	Chris Brandt <chris.brandt@renesas.com>
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/i2c/renesas,riic.yaml
F:	drivers/i2c/busses/i2c-riic.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

RENESAS RZ/G2L A/D DRIVER
M:	Lad Prabhakar <prabhakar.mahadev-lad.rj@bp.renesas.com>
L:	linux-iio@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/iio/adc/renesas,rzg2l-adc.yaml
F:	drivers/iio/adc/rzg2l_adc.c

RENESAS RZ/N1 A5PSW SWITCH DRIVER
M:	Clément Léger <clement.leger@bootlin.com>
L:	linux-renesas-soc@vger.kernel.org
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/dsa/renesas,rzn1-a5psw.yaml
F:	Documentation/devicetree/bindings/net/pcs/renesas,rzn1-miic.yaml
F:	drivers/net/dsa/rzn1_a5psw*
F:	drivers/net/pcs/pcs-rzn1-miic.c
F:	include/dt-bindings/net/pcs-rzn1-miic.h
F:	include/linux/pcs-rzn1-miic.h
F:	net/dsa/tag_rzn1_a5psw.c

RENESAS RZ/N1 RTC CONTROLLER DRIVER
M:	Miquel Raynal <miquel.raynal@bootlin.com>
L:	linux-rtc@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/rtc/renesas,rzn1-rtc.yaml
F:	drivers/rtc/rtc-rzn1.c

RENESAS R-CAR GEN3 & RZ/N1 NAND CONTROLLER DRIVER
M:	Miquel Raynal <miquel.raynal@bootlin.com>
L:	linux-mtd@lists.infradead.org
L:	linux-renesas-soc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/mtd/renesas-nandc.yaml
F:	drivers/mtd/nand/raw/renesas-nand-controller.c

RESET CONTROLLER FRAMEWORK
M:	Philipp Zabel <p.zabel@pengutronix.de>
S:	Maintained
T:	git git://git.pengutronix.de/git/pza/linux
F:	Documentation/devicetree/bindings/reset/
F:	Documentation/driver-api/reset.rst
F:	drivers/reset/
F:	include/dt-bindings/reset/
F:	include/linux/reset-controller.h
F:	include/linux/reset.h
F:	include/linux/reset/
K:	\b(?:devm_|of_)?reset_control(?:ler_[a-z]+|_[a-z_]+)?\b

RESTARTABLE SEQUENCES SUPPORT
M:	Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
M:	Peter Zijlstra <peterz@infradead.org>
M:	"Paul E. McKenney" <paulmck@kernel.org>
M:	Boqun Feng <boqun.feng@gmail.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	include/trace/events/rseq.h
F:	include/uapi/linux/rseq.h
F:	kernel/rseq.c
F:	tools/testing/selftests/rseq/

RFKILL
M:	Johannes Berg <johannes@sipsolutions.net>
L:	linux-wireless@vger.kernel.org
S:	Maintained
W:	https://wireless.wiki.kernel.org/
Q:	https://patchwork.kernel.org/project/linux-wireless/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/wireless/wireless.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/wireless/wireless-next.git
F:	Documentation/ABI/stable/sysfs-class-rfkill
F:	Documentation/driver-api/rfkill.rst
F:	include/linux/rfkill.h
F:	include/uapi/linux/rfkill.h
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:	include/linux/rhashtable-types.h
F:	include/linux/rhashtable.h
F:	lib/rhashtable.c
F:	lib/test_rhashtable.c

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 PMU DRIVERS
M:	Atish Patra <atishp@atishpatra.org>
R:	Anup Patel <anup@brainfault.org>
L:	linux-riscv@lists.infradead.org
S:	Supported
F:	drivers/perf/riscv_pmu.c
F:	drivers/perf/riscv_pmu_legacy.c
F:	drivers/perf/riscv_pmu_sbi.c

RISC-V ARCHITECTURE
M:	Paul Walmsley <paul.walmsley@sifive.com>
M:	Palmer Dabbelt <palmer@dabbelt.com>
M:	Albert Ou <aou@eecs.berkeley.edu>
L:	linux-riscv@lists.infradead.org
S:	Supported
P:	Documentation/riscv/patch-acceptance.rst
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/riscv/linux.git
F:	arch/riscv/
N:	riscv
K:	riscv

RISC-V/MICROCHIP POLARFIRE SOC SUPPORT
M:	Conor Dooley <conor.dooley@microchip.com>
M:	Daire McNamara <daire.mcnamara@microchip.com>
L:	linux-riscv@lists.infradead.org
S:	Supported
F:	arch/riscv/boot/dts/microchip/
F:	drivers/char/hw_random/mpfs-rng.c
F:	drivers/clk/microchip/clk-mpfs.c
F:	drivers/mailbox/mailbox-mpfs.c
F:	drivers/pci/controller/pcie-microchip-host.c
F:	drivers/soc/microchip/
F:	drivers/spi/spi-microchip-core.c
F:	drivers/usb/musb/mpfs.c
F:	include/soc/microchip/mpfs.h

RNBD BLOCK DRIVERS
M:	Md. Haris Iqbal <haris.iqbal@ionos.com>
M:	Jack Wang <jinpu.wang@ionos.com>
L:	linux-block@vger.kernel.org
S:	Maintained
F:	drivers/block/rnbd/

ROCCAT DRIVERS
M:	Stefan Achatz <erazor_de@users.sourceforge.net>
S:	Maintained
W:	http://sourceforge.net/projects/roccat/
F:	Documentation/ABI/*/sysfs-driver-hid-roccat*
F:	drivers/hid/hid-roccat*
F:	include/linux/hid-roccat*

ROCKCHIP I2S TDM DRIVER
M:	Nicolas Frattaroli <frattaroli.nicolas@gmail.com>
L:	linux-rockchip@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/sound/rockchip,i2s-tdm.yaml
F:	sound/soc/rockchip/rockchip_i2s_tdm.*

ROCKCHIP ISP V1 DRIVER
M:	Dafna Hirschfeld <dafna@fastmail.com>
L:	linux-media@vger.kernel.org
L:	linux-rockchip@lists.infradead.org
S:	Maintained
F:	Documentation/admin-guide/media/rkisp1.rst
F:	Documentation/devicetree/bindings/media/rockchip-isp1.yaml
F:	Documentation/userspace-api/media/v4l/pixfmt-meta-rkisp1.rst
F:	drivers/media/platform/rockchip/rkisp1
F:	include/uapi/linux/rkisp1-config.h

ROCKCHIP RASTER 2D GRAPHIC ACCELERATION UNIT DRIVER
M:	Jacob Chen <jacob-chen@iotwrt.com>
M:	Ezequiel Garcia <ezequiel@vanguardiasur.com.ar>
L:	linux-media@vger.kernel.org
L:	linux-rockchip@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/rockchip-rga.yaml
F:	drivers/media/platform/rockchip/rga/

ROCKCHIP VIDEO DECODER DRIVER
M:	Ezequiel Garcia <ezequiel@vanguardiasur.com.ar>
L:	linux-media@vger.kernel.org
L:	linux-rockchip@lists.infradead.org
S:	Maintained
F:	Documentation/devicetree/bindings/media/rockchip,vdec.yaml
F:	drivers/staging/media/rkvdec/

ROCKER DRIVER
M:	Jiri Pirko <jiri@resnulli.us>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/rocker/

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 BD99954 CHARGER IC
R:	Matti Vaittinen <mazziesaccount@gmail.com>
S:	Supported
F:	drivers/power/supply/bd99954-charger.c
F:	drivers/power/supply/bd99954-charger.h

ROHM BH1750 AMBIENT LIGHT SENSOR DRIVER
M:	Tomasz Duszynski <tduszyns@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/iio/light/bh1750.yaml
F:	drivers/iio/light/bh1750.c

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:	Documentation/devicetree/bindings/mfd/rohm,bd9571mwv.yaml
F:	drivers/gpio/gpio-bd9571mwv.c
F:	drivers/mfd/bd9571mwv.c
F:	drivers/regulator/bd9571mwv-regulator.c
F:	include/linux/mfd/bd9571mwv.h

ROHM POWER MANAGEMENT IC DEVICE DRIVERS
R:	Matti Vaittinen <mazziesaccount@gmail.com>
S:	Supported
F:	drivers/clk/clk-bd718x7.c
F:	drivers/gpio/gpio-bd71815.c
F:	drivers/gpio/gpio-bd71828.c
F:	drivers/mfd/rohm-bd71828.c
F:	drivers/mfd/rohm-bd718x7.c
F:	drivers/mfd/rohm-bd9576.c
F:	drivers/regulator/bd71815-regulator.c
F:	drivers/regulator/bd71828-regulator.c
F:	drivers/regulator/bd718x7-regulator.c
F:	drivers/regulator/bd9576-regulator.c
F:	drivers/regulator/rohm-regulator.c
F:	drivers/rtc/rtc-bd70528.c
F:	drivers/watchdog/bd9576_wdt.c
F:	include/linux/mfd/rohm-bd71815.h
F:	include/linux/mfd/rohm-bd71828.h
F:	include/linux/mfd/rohm-bd718x7.h
F:	include/linux/mfd/rohm-bd957x.h
F:	include/linux/mfd/rohm-generic.h
F:	include/linux/mfd/rohm-shared.h

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

ROTATION DRIVER FOR ALLWINNER A83T
M:	Jernej Skrabec <jernej.skrabec@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/allwinner,sun8i-a83t-de2-rotate.yaml
F:	drivers/media/platform/sunxi/sun8i-rotate/

RPMSG TTY DRIVER
M:	Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>
L:	linux-remoteproc@vger.kernel.org
S:	Maintained
F:	drivers/tty/rpmsg_tty.c

RTL2830 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/rtl2830*

RTL2832 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/rtl2832*

RTL2832_SDR MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/rtl2832_sdr*

RTL8180 WIRELESS DRIVER
L:	linux-wireless@vger.kernel.org
S:	Orphan
W:	https://wireless.wiki.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-testing.git
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
S:	Maintained
W:	https://wireless.wiki.kernel.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-testing.git
F:	drivers/net/wireless/realtek/rtl818x/rtl8187/

RTL8XXXU WIRELESS DRIVER (rtl8xxxu)
M:	Jes Sorensen <Jes.Sorensen@gmail.com>
L:	linux-wireless@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jes/linux.git rtl8xxxu-devel
F:	drivers/net/wireless/realtek/rtl8xxxu/

RTRS TRANSPORT DRIVERS
M:	Md. Haris Iqbal <haris.iqbal@ionos.com>
M:	Jack Wang <jinpu.wang@ionos.com>
L:	linux-rdma@vger.kernel.org
S:	Maintained
F:	drivers/infiniband/ulp/rtrs/

RXRPC SOCKETS (AF_RXRPC)
M:	David Howells <dhowells@redhat.com>
M:	Marc Dionne <marc.dionne@auristor.com>
L:	linux-afs@lists.infradead.org
S:	Supported
W:	https://www.infradead.org/~dhowells/kafs/
F:	Documentation/networking/rxrpc.rst
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:	net/rxrpc/

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:	Heiko Carstens <hca@linux.ibm.com>
M:	Vasily Gorbik <gor@linux.ibm.com>
M:	Alexander Gordeev <agordeev@linux.ibm.com>
R:	Christian Borntraeger <borntraeger@linux.ibm.com>
R:	Sven Schnelle <svens@linux.ibm.com>
L:	linux-s390@vger.kernel.org
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux.git
F:	Documentation/driver-api/s390-drivers.rst
F:	Documentation/s390/
F:	arch/s390/
F:	drivers/s390/

S390 COMMON I/O LAYER
M:	Vineeth Vijayan <vneethv@linux.ibm.com>
M:	Peter Oberparleiter <oberpar@linux.ibm.com>
L:	linux-s390@vger.kernel.org
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
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
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
F:	block/partitions/ibm.c
F:	drivers/s390/block/dasd*
F:	include/linux/dasd_mod.h

S390 IOMMU (PCI)
M:	Matthew Rosato <mjrosato@linux.ibm.com>
M:	Gerald Schaefer <gerald.schaefer@linux.ibm.com>
L:	linux-s390@vger.kernel.org
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
F:	drivers/iommu/s390-iommu.c

S390 IUCV NETWORK LAYER
M:	Alexandra Winter <wintera@linux.ibm.com>
M:	Wenjia Zhang <wenjia@linux.ibm.com>
L:	linux-s390@vger.kernel.org
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
F:	drivers/s390/net/*iucv*
F:	include/net/iucv/
F:	net/iucv/

S390 NETWORK DRIVERS
M:	Alexandra Winter <wintera@linux.ibm.com>
M:	Wenjia Zhang <wenjia@linux.ibm.com>
L:	linux-s390@vger.kernel.org
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
F:	drivers/s390/net/

S390 PCI SUBSYSTEM
M:	Niklas Schnelle <schnelle@linux.ibm.com>
M:	Gerald Schaefer <gerald.schaefer@linux.ibm.com>
L:	linux-s390@vger.kernel.org
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
F:	arch/s390/pci/
F:	drivers/pci/hotplug/s390_pci_hpc.c
F:	Documentation/s390/pci.rst

S390 VFIO AP DRIVER
M:	Tony Krowiak <akrowiak@linux.ibm.com>
M:	Halil Pasic <pasic@linux.ibm.com>
M:	Jason Herne <jjherne@linux.ibm.com>
L:	linux-s390@vger.kernel.org
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
F:	Documentation/s390/vfio-ap.rst
F:	drivers/s390/crypto/vfio_ap*

S390 VFIO-CCW DRIVER
M:	Eric Farman <farman@linux.ibm.com>
M:	Matthew Rosato <mjrosato@linux.ibm.com>
R:	Halil Pasic <pasic@linux.ibm.com>
L:	linux-s390@vger.kernel.org
L:	kvm@vger.kernel.org
S:	Supported
F:	Documentation/s390/vfio-ccw.rst
F:	drivers/s390/cio/vfio_ccw*
F:	include/uapi/linux/vfio_ccw.h

S390 VFIO-PCI DRIVER
M:	Matthew Rosato <mjrosato@linux.ibm.com>
M:	Eric Farman <farman@linux.ibm.com>
L:	linux-s390@vger.kernel.org
L:	kvm@vger.kernel.org
S:	Supported
F:	arch/s390/kvm/pci*
F:	drivers/vfio/pci/vfio_pci_zdev.c
F:	include/uapi/linux/vfio_zdev.h

S390 ZCRYPT DRIVER
M:	Harald Freudenberger <freude@linux.ibm.com>
L:	linux-s390@vger.kernel.org
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
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
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
F:	drivers/s390/scsi/zfcp_*

S3C ADC BATTERY DRIVER
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
L:	linux-samsung-soc@vger.kernel.org
S:	Odd Fixes
F:	drivers/power/supply/s3c_adc_battery.c
F:	include/linux/s3c_adc_battery.h

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
S:	Odd Fixes
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/saa6588*

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

SAA7146 VIDEO4LINUX-2 DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/common/saa7146/
F:	drivers/media/pci/saa7146/
F:	include/media/drv-intf/saa7146*

SAFESETID SECURITY MODULE
M:	Micah Morton <mortonm@chromium.org>
S:	Supported
F:	Documentation/admin-guide/LSM/SafeSetID.rst
F:	security/safesetid/

SAMSUNG AUDIO (ASoC) DRIVERS
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
B:	mailto:linux-samsung-soc@vger.kernel.org
F:	Documentation/devicetree/bindings/sound/samsung*
F:	sound/soc/samsung/

SAMSUNG EXYNOS PSEUDO RANDOM NUMBER GENERATOR (RNG) DRIVER
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
L:	linux-crypto@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/rng/samsung,exynos4-rng.yaml
F:	drivers/crypto/exynos-rng.c

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:	Documentation/devicetree/bindings/rng/samsung,exynos5250-trng.yaml
F:	drivers/char/hw_random/exynos-trng.c

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 INTERCONNECT DRIVERS
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
M:	Artur Świgoń <a.swigon@samsung.com>
L:	linux-pm@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Supported
F:	drivers/interconnect/samsung/

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:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
M:	Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
L:	linux-kernel@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Supported
B:	mailto:linux-samsung-soc@vger.kernel.org
F:	Documentation/devicetree/bindings/clock/samsung,s2mps11.yaml
F:	Documentation/devicetree/bindings/mfd/samsung,s2m*.yaml
F:	Documentation/devicetree/bindings/mfd/samsung,s5m*.yaml
F:	Documentation/devicetree/bindings/regulator/samsung,s2m*.yaml
F:	Documentation/devicetree/bindings/regulator/samsung,s5m*.yaml
F:	drivers/clk/clk-s2mps11.c
F:	drivers/mfd/sec*.c
F:	drivers/regulator/s2m*.c
F:	drivers/regulator/s5m*.c
F:	drivers/rtc/rtc-s5m.c
F:	include/linux/mfd/samsung/

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
S:	Maintained
F:	drivers/media/platform/samsung/s3c-camif/
F:	include/media/drv-intf/s3c_camif.h

SAMSUNG S3FWRN5 NFC DRIVER
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
M:	Krzysztof Opasiak <k.opasiak@samsung.com>
L:	linux-nfc@lists.01.org (subscribers-only)
S:	Maintained
F:	Documentation/devicetree/bindings/net/nfc/samsung,s3fwrn5.yaml
F:	drivers/nfc/s3fwrn5

SAMSUNG S5C73M3 CAMERA DRIVER
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
M:	Andrzej Hajda <andrzej.hajda@intel.com>
L:	linux-media@vger.kernel.org
S:	Supported
F:	drivers/media/i2c/s5c73m3/*

SAMSUNG S5K5BAF CAMERA DRIVER
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
M:	Andrzej Hajda <andrzej.hajda@intel.com>
L:	linux-media@vger.kernel.org
S:	Supported
F:	drivers/media/i2c/s5k5baf.c

SAMSUNG S5P Security SubSystem (SSS) DRIVER
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
M:	Vladimir Zapolskiy <vz@mleia.com>
L:	linux-crypto@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/crypto/samsung-slimsss.yaml
F:	Documentation/devicetree/bindings/crypto/samsung-sss.yaml
F:	drivers/crypto/s5p-sss.c

SAMSUNG S5P/EXYNOS4 SOC SERIES CAMERA SUBSYSTEM DRIVERS
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
L:	linux-media@vger.kernel.org
S:	Supported
Q:	https://patchwork.linuxtv.org/project/linux-media/list/
F:	drivers/media/platform/samsung/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>
R:	Alim Akhtar <alim.akhtar@samsung.com>
L:	linux-samsung-soc@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/snawrocki/clk.git
F:	Documentation/devicetree/bindings/clock/samsung,*.yaml
F:	Documentation/devicetree/bindings/clock/samsung,s3c*
F:	drivers/clk/samsung/
F:	include/dt-bindings/clock/exynos*.h
F:	include/dt-bindings/clock/s3c*.h
F:	include/dt-bindings/clock/s5p*.h
F:	include/dt-bindings/clock/samsung,*.h
F:	include/linux/clk/samsung.h
F:	include/linux/platform_data/clk-s3c2410.h

SAMSUNG SPI DRIVERS
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
M:	Andi Shyti <andi@etezian.org>
L:	linux-spi@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/spi/samsung,spi*.yaml
F:	drivers/spi/spi-s3c*
F:	include/linux/platform_data/spi-s3c64xx.h
F:	include/linux/spi/s3c24xx-fiq.h

SAMSUNG SXGBE DRIVERS
M:	Byungho An <bh74.an@samsung.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/samsung/sxgbe/

SAMSUNG THERMAL DRIVER
M:	Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
M:	Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
L:	linux-pm@vger.kernel.org
L:	linux-samsung-soc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/thermal/samsung,exynos-thermal.yaml
F:	drivers/thermal/samsung/

SAMSUNG USB2 PHY DRIVER
M:	Sylwester Nawrocki <s.nawrocki@samsung.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/phy/samsung,usb2-phy.yaml
F:	Documentation/driver-api/phy/samsung-usb2.rst
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

SANCLOUD BEAGLEBONE ENHANCED DEVICE TREE
M:	Paul Barker <paul.barker@sancloud.com>
R:	Marc Murphy <marc.murphy@sancloud.com>
S:	Supported
F:	arch/arm/boot/dts/am335x-sancloud*

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>
M:	Juri Lelli <juri.lelli@redhat.com> (SCHED_DEADLINE)
M:	Vincent Guittot <vincent.guittot@linaro.org> (SCHED_NORMAL)
R:	Dietmar Eggemann <dietmar.eggemann@arm.com> (SCHED_NORMAL)
R:	Steven Rostedt <rostedt@goodmis.org> (SCHED_FIFO/SCHED_RR)
R:	Ben Segall <bsegall@google.com> (CONFIG_CFS_BANDWIDTH)
R:	Mel Gorman <mgorman@suse.de> (CONFIG_NUMA_BALANCING)
R:	Daniel Bristot de Oliveira <bristot@redhat.com> (SCHED_DEADLINE)
R:	Valentin Schneider <vschneid@redhat.com> (TOPOLOGY)
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git sched/core
F:	include/linux/preempt.h
F:	include/linux/sched.h
F:	include/linux/wait.h
F:	include/uapi/linux/sched.h
F:	kernel/sched/

SCR24X CHIP CARD INTERFACE DRIVER
M:	Lubomir Rintel <lkundrak@v3.sk>
S:	Supported
F:	drivers/char/pcmcia/scr24x_cs.c

SCSI RDMA PROTOCOL (SRP) INITIATOR
M:	Bart Van Assche <bvanassche@acm.org>
L:	linux-rdma@vger.kernel.org
S:	Supported
Q:	http://patchwork.kernel.org/project/linux-rdma/list/
F:	drivers/infiniband/ulp/srp/
F:	include/scsi/srp.h

SCSI RDMA PROTOCOL (SRP) TARGET
M:	Bart Van Assche <bvanassche@acm.org>
L:	linux-rdma@vger.kernel.org
L:	target-devel@vger.kernel.org
S:	Supported
Q:	http://patchwork.kernel.org/project/linux-rdma/list/
F:	drivers/infiniband/ulp/srpt/

SCSI SG DRIVER
M:	Doug Gilbert <dgilbert@interlog.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
W:	http://sg.danny.cz/sg
F:	Documentation/scsi/scsi-generic.rst
F:	drivers/scsi/sg.c
F:	include/scsi/sg.h

SCSI SUBSYSTEM
M:	"James E.J. Bottomley" <jejb@linux.ibm.com>
M:	"Martin K. Petersen" <martin.petersen@oracle.com>
L:	linux-scsi@vger.kernel.org
S:	Maintained
Q:	https://patchwork.kernel.org/project/linux-scsi/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi.git
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mkp/scsi.git
F:	Documentation/devicetree/bindings/scsi/
F:	drivers/scsi/
F:	drivers/ufs/
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.rst
F:	drivers/scsi/st.*
F:	drivers/scsi/st_*.h

SCSI TARGET CORE USER DRIVER
M:	Bodo Stroesser <bostroesser@gmail.com>
L:	linux-scsi@vger.kernel.org
L:	target-devel@vger.kernel.org
S:	Supported
F:	Documentation/target/tcmu-design.rst
F:	drivers/target/target_core_user.c
F:	include/uapi/linux/target_core_user.h

SCSI TARGET SUBSYSTEM
M:	"Martin K. Petersen" <martin.petersen@oracle.com>
L:	linux-scsi@vger.kernel.org
L:	target-devel@vger.kernel.org
S:	Supported
W:	http://www.linux-iscsi.org
Q:	https://patchwork.kernel.org/project/target-devel/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mkp/scsi.git
F:	Documentation/target/
F:	drivers/target/
F:	include/target/

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
S:	Maintained
W:	http://lksctp.sourceforge.net
F:	Documentation/networking/sctp.rst
F:	include/linux/sctp.h
F:	include/net/sctp/
F:	include/uapi/linux/sctp.h
F:	net/sctp/

SCx200 CPU SUPPORT
M:	Jim Cromie <jim.cromie@gmail.com>
S:	Odd Fixes
F:	Documentation/i2c/busses/scx200_acb.rst
F:	arch/x86/platform/scx200/
F:	drivers/i2c/busses/scx200*
F:	drivers/mtd/maps/scx200_docflash.c
F:	drivers/watchdog/scx200_wdt.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

SECO BOARDS CEC DRIVER
M:	Ettore Chimenti <ek5.chimenti@gmail.com>
S:	Maintained
F:	drivers/media/cec/platform/seco/seco-cec.c
F:	drivers/media/cec/platform/seco/seco-cec.h

SECURE COMPUTING
M:	Kees Cook <keescook@chromium.org>
R:	Andy Lutomirski <luto@amacapital.net>
R:	Will Drewry <wad@chromium.org>
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/seccomp
F:	Documentation/userspace-api/seccomp_filter.rst
F:	include/linux/seccomp.h
F:	include/uapi/linux/seccomp.h
F:	kernel/seccomp.c
F:	tools/testing/selftests/kselftest_harness.h
F:	tools/testing/selftests/seccomp/*
K:	\bsecure_computing
K:	\bTIF_SECCOMP\b

SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) Broadcom BRCMSTB DRIVER
M:	Al Cooper <alcooperx@gmail.com>
R:	Broadcom internal kernel review list <bcm-kernel-feedback-list@broadcom.com>
L:	linux-mmc@vger.kernel.org
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
S:	Maintained
F:	drivers/mmc/host/sdhci*

SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) MICROCHIP DRIVER
M:	Eugen Hristev <eugen.hristev@microchip.com>
L:	linux-mmc@vger.kernel.org
S:	Supported
F:	drivers/mmc/host/sdhci-of-at91.c

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 DIGITAL HOST CONTROLLER INTERFACE (SDHCI) NXP i.MX DRIVER
M:	Haibo Chen <haibo.chen@nxp.com>
L:	linux-imx@nxp.com
L:	linux-mmc@vger.kernel.org
S:	Maintained
F:	drivers/mmc/host/sdhci-esdhc-imx.c

SECURE ENCRYPTING DEVICE (SED) OPAL DRIVER
M:	Jonathan Derrick <jonathan.derrick@intel.com>
M:	Revanth Rajashekar <revanth.rajashekar@intel.com>
L:	linux-block@vger.kernel.org
S:	Supported
F:	block/opal_proto.h
F:	block/sed*
F:	include/linux/sed*
F:	include/uapi/linux/sed*

SECURITY CONTACT
M:	Security Officers <security@kernel.org>
S:	Supported
F:	Documentation/admin-guide/security-bugs.rst

SECURITY SUBSYSTEM
M:	Paul Moore <paul@paul-moore.com>
M:	James Morris <jmorris@namei.org>
M:	"Serge E. Hallyn" <serge@hallyn.com>
L:	linux-security-module@vger.kernel.org (suggested Cc:)
S:	Supported
W:	http://kernsec.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pcmoore/lsm.git
F:	security/
X:	security/selinux/

SELINUX SECURITY MODULE
M:	Paul Moore <paul@paul-moore.com>
M:	Stephen Smalley <stephen.smalley.work@gmail.com>
M:	Eric Paris <eparis@parisplace.org>
L:	selinux@vger.kernel.org
S:	Supported
W:	https://selinuxproject.org
W:	https://github.com/SELinuxProject
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pcmoore/selinux.git
F:	Documentation/ABI/obsolete/sysfs-selinux-checkreqprot
F:	Documentation/ABI/obsolete/sysfs-selinux-disable
F:	Documentation/admin-guide/LSM/SELinux.rst
F:	include/trace/events/avc.h
F:	include/uapi/linux/selinux_netlink.h
F:	scripts/selinux/
F:	security/selinux/

SENSABLE PHANTOM
M:	Jiri Slaby <jirislaby@kernel.org>
S:	Maintained
F:	drivers/misc/phantom.c
F:	include/uapi/linux/phantom.h

SENSEAIR SUNRISE 006-0-0007
M:	Jacopo Mondi <jacopo@jmondi.org>
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-iio-chemical-sunrise-co2
F:	Documentation/devicetree/bindings/iio/chemical/senseair,sunrise.yaml
F:	drivers/iio/chemical/sunrise_co2.c

SENSIRION SCD30 CARBON DIOXIDE SENSOR DRIVER
M:	Tomasz Duszynski <tomasz.duszynski@octakon.com>
S:	Maintained
F:	Documentation/devicetree/bindings/iio/chemical/sensirion,scd30.yaml
F:	drivers/iio/chemical/scd30.h
F:	drivers/iio/chemical/scd30_core.c
F:	drivers/iio/chemical/scd30_i2c.c
F:	drivers/iio/chemical/scd30_serial.c

SENSIRION SCD4X CARBON DIOXIDE SENSOR DRIVER
M:	Roan van Dijk <roan@protonic.nl>
S:	Maintained
F:	Documentation/devicetree/bindings/iio/chemical/sensirion,scd4x.yaml
F:	drivers/iio/chemical/scd4x.c

SENSIRION SGP40 GAS SENSOR DRIVER
M:	Andreas Klinger <ak@it-klinger.de>
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-iio-chemical-sgp40
F:	drivers/iio/chemical/sgp40.c

SENSIRION SPS30 AIR POLLUTION SENSOR DRIVER
M:	Tomasz Duszynski <tduszyns@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/iio/chemical/sensirion,sps30.yaml
F:	drivers/iio/chemical/sps30.c
F:	drivers/iio/chemical/sps30_i2c.c
F:	drivers/iio/chemical/sps30_serial.c

SERIAL DEVICE BUS
M:	Rob Herring <robh@kernel.org>
L:	linux-serial@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/serial/serial.yaml
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

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:	Documentation/devicetree/bindings/slimbus/
F:	drivers/slimbus/
F:	include/linux/slimbus.h

SFC NETWORK DRIVER
M:	Edward Cree <ecree.xilinx@gmail.com>
M:	Martin Habets <habetsm.xilinx@gmail.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/ethernet/sfc/

SFF/SFP/SFP+ MODULE SUPPORT
M:	Russell King <linux@armlinux.org.uk>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/sff,sfp.yaml
F:	drivers/net/phy/phylink.c
F:	drivers/net/phy/sfp*
F:	include/linux/mdio/mdio-i2c.h
F:	include/linux/phylink.h
F:	include/linux/sfp.h
K:	phylink\.h|struct\s+phylink|\.phylink|>phylink_|phylink_(autoneg|clear|connect|create|destroy|disconnect|ethtool|helper|mac|mii|of|set|start|stop|test|validate)

SGI GRU DRIVER
M:	Dimitri Sivanich <dimitri.sivanich@hpe.com>
S:	Maintained
F:	drivers/misc/sgi-gru/

SGI XP/XPC/XPNET DRIVER
M:	Robin Holt <robinmholt@gmail.com>
M:	Steve Wahl <steve.wahl@hpe.com>
R:	Mike Travis <mike.travis@hpe.com>
S:	Maintained
F:	drivers/misc/sgi-xp/

SHARED MEMORY COMMUNICATIONS (SMC) SOCKETS
M:	Karsten Graul <kgraul@linux.ibm.com>
M:	Wenjia Zhang <wenjia@linux.ibm.com>
L:	linux-s390@vger.kernel.org
S:	Supported
W:	http://www.ibm.com/developerworks/linux/linux390/
F:	net/smc/

SHARP GP2AP002A00F/GP2AP002S00F SENSOR DRIVER
M:	Linus Walleij <linus.walleij@linaro.org>
L:	linux-iio@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio.git
F:	Documentation/devicetree/bindings/iio/light/sharp,gp2ap002.yaml
F:	drivers/iio/light/gp2ap002.c

SHARP RJ54N1CB0C SENSOR DRIVER
M:	Jacopo Mondi <jacopo@jmondi.org>
L:	linux-media@vger.kernel.org
S:	Odd fixes
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/rj54n1cb0c.c
F:	include/media/i2c/rj54n1cb0c.h

SH_VOU V4L2 OUTPUT DRIVER
L:	linux-media@vger.kernel.org
S:	Orphan
F:	drivers/media/platform/renesas/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
S:	Maintained
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
F:	drivers/media/tuners/si2157*

SI2165 MEDIA DRIVER
M:	Matthias Schwarzott <zzam@gentoo.org>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
F:	drivers/media/dvb-frontends/si2165*

SI2168 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/si2168*

SI470X FM RADIO RECEIVER I2C DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/radio/si470x/radio-si470x-common.c
F:	drivers/media/radio/si470x/radio-si470x-usb.c
F:	drivers/media/radio/si470x/radio-si470x.h

SI4713 FM RADIO TRANSMITTER I2C DRIVER
M:	Eduardo Valentin <edubezval@gmail.com>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/radio/si4713/si4713.?

SI4713 FM RADIO TRANSMITTER PLATFORM DRIVER
M:	Eduardo Valentin <edubezval@gmail.com>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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
S:	Odd fixes
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/common/siano/
F:	drivers/media/mmc/siano/
F:	drivers/media/usb/siano/
F:	drivers/media/usb/siano/

SIFIVE DRIVERS
M:	Palmer Dabbelt <palmer@dabbelt.com>
M:	Paul Walmsley <paul.walmsley@sifive.com>
L:	linux-riscv@lists.infradead.org
S:	Supported
T:	git git://github.com/sifive/riscv-linux.git
N:	sifive
K:	[^@]sifive

SIFIVE FU540 SYSTEM-ON-CHIP
M:	Paul Walmsley <paul.walmsley@sifive.com>
M:	Palmer Dabbelt <palmer@dabbelt.com>
L:	linux-riscv@lists.infradead.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pjw/sifive.git
N:	fu540
K:	fu540

SIFIVE PDMA DRIVER
M:	Green Wan <green.wan@sifive.com>
S:	Maintained
F:	Documentation/devicetree/bindings/dma/sifive,fu540-c000-pdma.yaml
F:	drivers/dma/sf-pdma/

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/touchscreen_dmi.c

SILICON LABS WIRELESS DRIVERS (for WFxxx series)
M:	Jérôme Pouiller <jerome.pouiller@silabs.com>
S:	Supported
F:	Documentation/devicetree/bindings/net/wireless/silabs,wfx.yaml
F:	drivers/net/wireless/silabs/wfx/

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:	Documentation/fb/sm712fb.rst
F:	drivers/video/fbdev/sm712*

SILVACO I3C DUAL-ROLE MASTER
M:	Miquel Raynal <miquel.raynal@bootlin.com>
M:	Conor Culhane <conor.culhane@silvaco.com>
L:	linux-i3c@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/i3c/silvaco,i3c-master.yaml
F:	drivers/i3c/master/svc-i3c-master.c

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.yaml
F:	drivers/video/fbdev/simplefb.c
F:	include/linux/platform_data/simplefb.h

SIMTEC EB110ATX (Chalice CATS)
M:	Simtec Linux Team <linux@simtec.co.uk>
S:	Supported
W:	http://www.simtec.co.uk/products/EB110ATX/

SIMTEC EB2410ITX (BAST)
M:	Simtec Linux Team <linux@simtec.co.uk>
S:	Supported
W:	http://www.simtec.co.uk/products/EB2410ITX/
F:	arch/arm/mach-s3c/bast-ide.c
F:	arch/arm/mach-s3c/bast-irq.c
F:	arch/arm/mach-s3c/mach-bast.c

SIOX
M:	Thorsten Scherer <t.scherer@eckelmann.de>
M:	Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
R:	Pengutronix Kernel Team <kernel@pengutronix.de>
S:	Supported
F:	drivers/gpio/gpio-siox.c
F:	drivers/siox/*
F:	include/trace/events/siox.h

SIPHASH PRF ROUTINES
M:	Jason A. Donenfeld <Jason@zx2c4.com>
S:	Maintained
F:	include/linux/siphash.h
F:	lib/siphash.c
F:	lib/test_siphash.c

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>
L:	netdev@vger.kernel.org
S:	Maintained
W:	http://www.brownhat.org/sis900.html
F:	drivers/net/ethernet/sis/sis900.*

SIS FRAMEBUFFER DRIVER
M:	Thomas Winischhofer <thomas@winischhofer.net>
S:	Maintained
W:	http://www.winischhofer.net/linuxsisvga.shtml
F:	Documentation/fb/sisfb.rst
F:	drivers/video/fbdev/sis/
F:	include/video/sisfb.h

SIS I2C TOUCHSCREEN DRIVER
M:	Mika Penttilä <mika.penttila@nextfour.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/input/touchscreen/sis_i2c.txt
F:	drivers/input/touchscreen/sis_i2c.c

SIS USB2VGA DRIVER
M:	Thomas Winischhofer <thomas@winischhofer.net>
S:	Maintained
W:	http://www.winischhofer.at/linuxsisusbvga.shtml
F:	drivers/usb/misc/sisusbvga/

SL28 CPLD MFD DRIVER
M:	Michael Walle <michael@walle.cc>
S:	Maintained
F:	Documentation/devicetree/bindings/gpio/kontron,sl28cpld-gpio.yaml
F:	Documentation/devicetree/bindings/hwmon/kontron,sl28cpld-hwmon.yaml
F:	Documentation/devicetree/bindings/interrupt-controller/kontron,sl28cpld-intc.yaml
F:	Documentation/devicetree/bindings/mfd/kontron,sl28cpld.yaml
F:	Documentation/devicetree/bindings/pwm/kontron,sl28cpld-pwm.yaml
F:	Documentation/devicetree/bindings/watchdog/kontron,sl28cpld-wdt.yaml
F:	drivers/gpio/gpio-sl28cpld.c
F:	drivers/hwmon/sl28cpld-hwmon.c
F:	drivers/irqchip/irq-sl28cpld.c
F:	drivers/pwm/pwm-sl28cpld.c
F:	drivers/watchdog/sl28cpld_wdt.c

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>
M:	Vlastimil Babka <vbabka@suse.cz>
R:	Roman Gushchin <roman.gushchin@linux.dev>
R:	Hyeonggon Yoo <42.hyeyoo@gmail.com>
L:	linux-mm@kvack.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/vbabka/slab.git
F:	include/linux/sl?b*.h
F:	mm/sl?b*

SLCAN CAN NETWORK DRIVER
M:	Dario Binacchi <dario.binacchi@amarulasolutions.com>
L:	linux-can@vger.kernel.org
S:	Maintained
F:	drivers/net/can/slcan/

SLEEPABLE READ-COPY UPDATE (SRCU)
M:	Lai Jiangshan <jiangshanlai@gmail.com>
M:	"Paul E. McKenney" <paulmck@kernel.org>
M:	Josh Triplett <josh@joshtriplett.org>
R:	Steven Rostedt <rostedt@goodmis.org>
R:	Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
L:	rcu@vger.kernel.org
S:	Supported
W:	http://www.rdrop.com/users/paulmck/RCU/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git dev
F:	include/linux/srcu*.h
F:	kernel/rcu/srcu*.c

SMACK SECURITY MODULE
M:	Casey Schaufler <casey@schaufler-ca.com>
L:	linux-security-module@vger.kernel.org
S:	Maintained
W:	http://schaufler-ca.com
T:	git git://github.com/cschaufler/smack-next
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.*

SECURE MONITOR CALL(SMC) CALLING CONVENTION (SMCCC)
M:	Mark Rutland <mark.rutland@arm.com>
M:	Lorenzo Pieralisi <lpieralisi@kernel.org>
M:	Sudeep Holla <sudeep.holla@arm.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/firmware/smccc/
F:	include/linux/arm-smccc.h

SMM665 HARDWARE MONITOR DRIVER
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/smm665.rst
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.rst
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.rst
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.rst
F:	drivers/hwmon/smsc47b397.c

SMSC911x ETHERNET DRIVER
M:	Steve Glendinning <steve.glendinning@shawell.net>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/smsc/smsc911x.*
F:	include/linux/smsc911x.h

SMSC9420 PCI ETHERNET DRIVER
M:	Steve Glendinning <steve.glendinning@shawell.net>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/ethernet/smsc/smsc9420.*

SOCIONEXT (SNI) AVE NETWORK DRIVER
M:	Kunihiko Hayashi <hayashi.kunihiko@socionext.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/socionext,uniphier-ave4.yaml
F:	drivers/net/ethernet/socionext/sni_ave.c

SOCIONEXT (SNI) NETSEC NETWORK DRIVER
M:	Jassi Brar <jaswinder.singh@linaro.org>
M:	Ilias Apalodimas <ilias.apalodimas@linaro.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/socionext-netsec.txt
F:	drivers/net/ethernet/socionext/netsec.c

SOCIONEXT (SNI) Synquacer SPI DRIVER
M:	Masahisa Kojima <masahisa.kojima@linaro.org>
M:	Jassi Brar <jaswinder.singh@linaro.org>
L:	linux-spi@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/spi/spi-synquacer.txt
F:	drivers/spi/spi-synquacer.c

SOCIONEXT SYNQUACER I2C DRIVER
M:	Ard Biesheuvel <ardb@kernel.org>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/i2c/i2c-synquacer.txt
F:	drivers/i2c/busses/i2c-synquacer.c

SOCIONEXT UNIPHIER SOUND DRIVER
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Orphan
F:	sound/soc/uniphier/

SOEKRIS NET48XX LED SUPPORT
M:	Chris Boot <bootc@bootc.net>
S:	Maintained
F:	drivers/leds/leds-net48xx.c

SOFT-IWARP DRIVER (siw)
M:	Bernard Metzler <bmt@zurich.ibm.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
F:	drivers/infiniband/sw/siw/
F:	include/uapi/rdma/siw-abi.h

SOFT-ROCE DRIVER (rxe)
M:	Zhu Yanjun <zyjzyj2000@gmail.com>
L:	linux-rdma@vger.kernel.org
S:	Supported
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@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 (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/arm/firmware/sdei.txt
F:	drivers/firmware/arm_sdei.c
F:	include/linux/arm_sdei.h
F:	include/uapi/linux/arm_sdei.h

SOFTWARE NODES AND DEVICE PROPERTIES
R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
R:	Daniel Scally <djrscally@gmail.com>
R:	Heikki Krogerus <heikki.krogerus@linux.intel.com>
R:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-acpi@vger.kernel.org
S:	Maintained
F:	drivers/base/property.c
F:	drivers/base/swnode.c
F:	include/linux/fwnode.h
F:	include/linux/property.h

SOFTWARE RAID (Multiple Disks) SUPPORT
M:	Song Liu <song@kernel.org>
L:	linux-raid@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-raid/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/song/md.git
F:	drivers/md/Kconfig
F:	drivers/md/Makefile
F:	drivers/md/md*
F:	drivers/md/raid*
F:	include/linux/raid/
F:	include/uapi/linux/raid/

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 IMX208 SENSOR DRIVER
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/imx208.c

SONY IMX214 SENSOR DRIVER
M:	Ricardo Ribalda <ribalda@kernel.org>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/sony,imx214.yaml
F:	drivers/media/i2c/imx214.c

SONY IMX219 SENSOR DRIVER
M:	Dave Stevenson <dave.stevenson@raspberrypi.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/imx219.yaml
F:	drivers/media/i2c/imx219.c

SONY IMX258 SENSOR DRIVER
M:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/imx258.yaml
F:	drivers/media/i2c/imx258.c

SONY IMX274 SENSOR DRIVER
M:	Leon Luo <leonl@leopardimaging.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/sony,imx274.yaml
F:	drivers/media/i2c/imx274.c

SONY IMX290 SENSOR DRIVER
M:	Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/imx290.txt
F:	drivers/media/i2c/imx290.c

SONY IMX319 SENSOR DRIVER
M:	Bingbu Cao <bingbu.cao@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/imx319.c

SONY IMX334 SENSOR DRIVER
M:	Paul J. Murphy <paul.j.murphy@intel.com>
M:	Daniele Alessandrelli <daniele.alessandrelli@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/sony,imx334.yaml
F:	drivers/media/i2c/imx334.c

SONY IMX335 SENSOR DRIVER
M:	Paul J. Murphy <paul.j.murphy@intel.com>
M:	Daniele Alessandrelli <daniele.alessandrelli@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/sony,imx335.yaml
F:	drivers/media/i2c/imx335.c

SONY IMX355 SENSOR DRIVER
M:	Tianshu Qiu <tian.shu.qiu@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/imx355.c

SONY IMX412 SENSOR DRIVER
M:	Paul J. Murphy <paul.j.murphy@intel.com>
M:	Daniele Alessandrelli <daniele.alessandrelli@intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/sony,imx412.yaml
F:	drivers/media/i2c/imx412.c

SONY MEMORYSTICK SUBSYSTEM
M:	Maxim Levitsky <maximlevitsky@gmail.com>
M:	Alex Dubov <oakad@yahoo.com>
M:	Ulf Hansson <ulf.hansson@linaro.org>
L:	linux-mmc@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ulfh/mmc.git
F:	drivers/memstick/
F:	include/linux/memstick.h

SONY VAIO CONTROL DEVICE DRIVER
M:	Mattia Dongili <malattia@linux.it>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
W:	http://www.linux.it/~malattia/wiki/index.php/Sony_drivers
F:	Documentation/admin-guide/laptops/sony-laptop.rst
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)
S:	Maintained
W:	http://www.alsa-project.org/
Q:	http://patchwork.kernel.org/project/alsa-devel/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
F:	Documentation/sound/
F:	include/sound/
F:	include/uapi/sound/
F:	sound/
F:	tools/testing/selftests/alsa

SOUND - COMPRESSED AUDIO
M:	Vinod Koul <vkoul@kernel.org>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
F:	Documentation/sound/designs/compress-offload.rst
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 - ALSA SELFTESTS
M:	Mark Brown <broonie@kernel.org>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
L:	linux-kselftest@vger.kernel.org
S:	Supported
F:	tools/testing/selftests/alsa

SOUND - SOC LAYER / DYNAMIC AUDIO POWER MANAGEMENT (ASoC)
M:	Liam Girdwood <lgirdwood@gmail.com>
M:	Mark Brown <broonie@kernel.org>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
W:	http://alsa-project.org/main/index.php/ASoC
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound.git
F:	Documentation/devicetree/bindings/sound/
F:	Documentation/sound/soc/
F:	include/dt-bindings/sound/
F:	include/sound/soc*
F:	sound/soc/

SOUND - SOUND OPEN FIRMWARE (SOF) DRIVERS
M:	Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
M:	Liam Girdwood <lgirdwood@gmail.com>
M:	Peter Ujfalusi <peter.ujfalusi@linux.intel.com>
M:	Bard Liao <yung-chuan.liao@linux.intel.com>
M:	Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
R:	Kai Vehmanen <kai.vehmanen@linux.intel.com>
M:	Daniel Baluta <daniel.baluta@nxp.com>
L:	sound-open-firmware@alsa-project.org (moderated for non-subscribers)
S:	Supported
W:	https://github.com/thesofproject/linux/
F:	sound/soc/sof/

SOUNDWIRE SUBSYSTEM
M:	Vinod Koul <vkoul@kernel.org>
M:	Bard Liao <yung-chuan.liao@linux.intel.com>
R:	Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
R:	Sanyog Kale <sanyog.r.kale@intel.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/soundwire.git
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
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
F:	drivers/media/dvb-frontends/sp2*

SPARC + UltraSPARC (sparc/sparc64)
M:	"David S. Miller" <davem@davemloft.net>
L:	sparclinux@vger.kernel.org
S:	Maintained
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
F:	arch/sparc/
F:	drivers/sbus/

SPARC SERIAL DRIVERS
M:	"David S. Miller" <davem@davemloft.net>
L:	sparclinux@vger.kernel.org
S:	Maintained
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
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
F:	include/linux/sunserialcore.h

SPARSE CHECKER
M:	"Luc Van Oostenryck" <luc.vanoostenryck@gmail.com>
L:	linux-sparse@vger.kernel.org
S:	Maintained
W:	https://sparse.docs.kernel.org/
T:	git git://git.kernel.org/pub/scm/devel/sparse/sparse.git
Q:	https://patchwork.kernel.org/project/linux-sparse/list/
B:	https://bugzilla.kernel.org/enter_bug.cgi?component=Sparse&product=Tools
F:	include/linux/compiler.h

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
S:	Odd Fixes
W:	http://www.linux-speakup.org/
W:	https://github.com/linux-speakup/speakup
B:	https://github.com/linux-speakup/speakup/issues
F:	drivers/accessibility/speakup/

SPEAR PLATFORM/CLOCK/PINCTRL SUPPORT
M:	Viresh Kumar <vireshk@kernel.org>
M:	Shiraz Hashim <shiraz.linux.kernel@gmail.com>
M:	soc@kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
W:	http://www.st.com/spear
F:	arch/arm/boot/dts/spear*
F:	arch/arm/mach-spear/
F:	drivers/clk/spear/
F:	drivers/pinctrl/spear/

SPI NOR SUBSYSTEM
M:	Tudor Ambarus <tudor.ambarus@microchip.com>
M:	Pratyush Yadav <p.yadav@ti.com>
R:	Michael Walle <michael@walle.cc>
L:	linux-mtd@lists.infradead.org
S:	Maintained
W:	http://www.linux-mtd.infradead.org/
Q:	http://patchwork.ozlabs.org/project/linux-mtd/list/
C:	irc://irc.oftc.net/mtd
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mtd/linux.git spi-nor/next
F:	Documentation/devicetree/bindings/mtd/jedec,spi-nor.yaml
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
S:	Maintained
Q:	http://patchwork.kernel.org/project/spi-devel-general/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi.git
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>
M:	Geoff Levand <geoff@infradead.org>
L:	netdev@vger.kernel.org
L:	linuxppc-dev@lists.ozlabs.org
S:	Maintained
F:	Documentation/networking/device_drivers/ethernet/toshiba/spider_net.rst
F:	drivers/net/ethernet/toshiba/spider_net*

SPMI SUBSYSTEM
M:	Stephen Boyd <sboyd@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sboyd/spmi.git
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
S:	Supported
W:	http://www.ibm.com/developerworks/power/cell/
F:	Documentation/filesystems/spufs/spufs.rst
F:	arch/powerpc/platforms/cell/spufs/

SQUASHFS FILE SYSTEM
M:	Phillip Lougher <phillip@squashfs.org.uk>
L:	squashfs-devel@lists.sourceforge.net (subscribers-only)
S:	Maintained
W:	http://squashfs.org.uk
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pkl/squashfs-next.git
F:	Documentation/filesystems/squashfs.rst
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 LSM6DSx IMU IIO DRIVER
M:	Lorenzo Bianconi <lorenzo@kernel.org>
L:	linux-iio@vger.kernel.org
S:	Maintained
W:	http://www.st.com/
F:	Documentation/devicetree/bindings/iio/imu/st,lsm6dsx.yaml
F:	drivers/iio/imu/st_lsm6dsx/

ST MIPID02 CSI-2 TO PARALLEL BRIDGE DRIVER
M:	Benjamin Mugnier <benjamin.mugnier@foss.st.com>
M:	Sylvain Petinot <sylvain.petinot@foss.st.com>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/i2c/st,st-mipid02.txt
F:	drivers/media/i2c/st-mipid02.c

ST STM32 I2C/SMBUS DRIVER
M:	Pierre-Yves MORDRET <pierre-yves.mordret@foss.st.com>
M:	Alain Volmat <alain.volmat@foss.st.com>
L:	linux-i2c@vger.kernel.org
S:	Maintained
F:	drivers/i2c/busses/i2c-stm32*

ST STM32 SPI DRIVER
M:	Alain Volmat <alain.volmat@foss.st.com>
L:	linux-spi@vger.kernel.org
S:	Maintained
F:	drivers/spi/spi-stm32.c

ST STPDDC60 DRIVER
M:	Daniel Nilsson <daniel.nilsson@flex.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/stpddc60.rst
F:	drivers/hwmon/pmbus/stpddc60.c

ST VL53L0X ToF RANGER(I2C) IIO DRIVER
M:	Song Qiang <songqiang1304521@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/proximity/st,vl53l0x.yaml
F:	drivers/iio/proximity/vl53l0x-i2c.c

STABLE BRANCH
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
M:	Sasha Levin <sashal@kernel.org>
L:	stable@vger.kernel.org
S:	Supported
F:	Documentation/process/stable-kernel-rules.rst

STAGING - ATOMISP DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
R:	Sakari Ailus <sakari.ailus@linux.intel.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/staging/media/atomisp/

STAGING - FIELDBUS SUBSYSTEM
M:	Sven Van Asbroeck <TheSven73@gmail.com>
S:	Maintained
F:	drivers/staging/fieldbus/*
F:	drivers/staging/fieldbus/Documentation/

STAGING - HMS ANYBUS-S BUS
M:	Sven Van Asbroeck <TheSven73@gmail.com>
S:	Maintained
F:	drivers/staging/fieldbus/anybuss/

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:	Jon Nettleton <jon.nettleton@gmail.com>
S:	Maintained
W:	http://wiki.laptop.org/go/DCON
F:	drivers/staging/olpc_dcon/

STAGING - REALTEK RTL8188EU DRIVERS
M:	Larry Finger <Larry.Finger@lwfinger.net>
M:	Phillip Potter <phil@philpotter.co.uk>
R:	Pavel Skripkin <paskripkin@gmail.com>
S:	Supported
F:	drivers/staging/r8188eu/

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 - SEPS525 LCD CONTROLLER DRIVERS
M:	Michael Hennerich <michael.hennerich@analog.com>
L:	linux-fbdev@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/iio/adc/adi,ad7606.yaml
F:	drivers/staging/fbtft/fb_seps525.c

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 - VIA VT665X DRIVERS
M:	Forest Bond <forest@alittletooquiet.net>
S:	Odd Fixes
F:	drivers/staging/vt665?/

STAGING SUBSYSTEM
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
L:	linux-staging@lists.linux.dev
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git
F:	drivers/staging/

STARFIRE/DURALAN NETWORK DRIVER
M:	Ion Badulescu <ionut@badula.org>
S:	Odd Fixes
F:	drivers/net/ethernet/adaptec/starfire*

STARFIVE JH7100 CLOCK DRIVERS
M:	Emil Renner Berthing <kernel@esmil.dk>
S:	Maintained
F:	Documentation/devicetree/bindings/clock/starfive,jh7100-*.yaml
F:	drivers/clk/starfive/clk-starfive-jh7100*
F:	include/dt-bindings/clock/starfive-jh7100*.h

STARFIVE JH7100 PINCTRL DRIVER
M:	Emil Renner Berthing <kernel@esmil.dk>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/pinctrl/starfive,jh7100-pinctrl.yaml
F:	drivers/pinctrl/pinctrl-starfive.c
F:	include/dt-bindings/pinctrl/pinctrl-starfive.h

STARFIVE JH7100 RESET CONTROLLER DRIVER
M:	Emil Renner Berthing <kernel@esmil.dk>
S:	Maintained
F:	Documentation/devicetree/bindings/reset/starfive,jh7100-reset.yaml
F:	drivers/reset/reset-starfive-jh7100.c
F:	include/dt-bindings/reset/starfive-jh7100.h

STATIC BRANCH/CALL
M:	Peter Zijlstra <peterz@infradead.org>
M:	Josh Poimboeuf <jpoimboe@kernel.org>
M:	Jason Baron <jbaron@akamai.com>
R:	Steven Rostedt <rostedt@goodmis.org>
R:	Ard Biesheuvel <ardb@kernel.org>
S:	Supported
F:	arch/*/include/asm/jump_label*.h
F:	arch/*/include/asm/static_call*.h
F:	arch/*/kernel/jump_label.c
F:	arch/*/kernel/static_call.c
F:	include/linux/jump_label*.h
F:	include/linux/static_call*.h
F:	kernel/jump_label.c
F:	kernel/static_call.c

STI AUDIO (ASoC) DRIVERS
M:	Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/sound/st,sti-asoc-card.txt
F:	sound/soc/sti/

STI CEC DRIVER
M:	Alain Volmat <alain.volmat@foss.st.com>
S:	Maintained
F:	Documentation/devicetree/bindings/media/stih-cec.txt
F:	drivers/media/cec/platform/sti/

STK1160 USB VIDEO CAPTURE DRIVER
M:	Ezequiel Garcia <ezequiel@vanguardiasur.com.ar>
L:	linux-media@vger.kernel.org
S:	Maintained
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/usb/stk1160/

STM32 AUDIO (ASoC) DRIVERS
M:	Olivier Moysan <olivier.moysan@foss.st.com>
M:	Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/iio/adc/st,stm32-dfsdm-adc.yaml
F:	Documentation/devicetree/bindings/sound/st,stm32-*.yaml
F:	sound/soc/stm/

STM32 TIMER/LPTIMER DRIVERS
M:	Fabrice Gasnier <fabrice.gasnier@foss.st.com>
S:	Maintained
F:	Documentation/ABI/testing/*timer-stm32
F:	Documentation/devicetree/bindings/*/*stm32-*timer*
F:	drivers/*/stm32-*timer*
F:	drivers/pwm/pwm-stm32*
F:	include/linux/*/stm32-*tim*

STMMAC ETHERNET DRIVER
M:	Giuseppe Cavallaro <peppe.cavallaro@st.com>
M:	Alexandre Torgue <alexandre.torgue@foss.st.com>
M:	Jose Abreu <joabreu@synopsys.com>
L:	netdev@vger.kernel.org
S:	Supported
W:	http://www.stlinux.com
F:	Documentation/networking/device_drivers/ethernet/stmicro/
F:	drivers/net/ethernet/stmicro/stmmac/

SUN3/3X
M:	Sam Creasey <sammy@sammy.net>
S:	Maintained
W:	http://sammy.net/sun3/
F:	arch/m68k/include/asm/sun3*
F:	arch/m68k/kernel/*sun3*
F:	arch/m68k/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/allwinner,sun4i-a10-lradc-keys.yaml
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

SUNPLUS ETHERNET DRIVER
M:	Wells Lu <wellslutw@gmail.com>
L:	netdev@vger.kernel.org
S:	Maintained
W:	https://sunplus.atlassian.net/wiki/spaces/doc/overview
F:	Documentation/devicetree/bindings/net/sunplus,sp7021-emac.yaml
F:	drivers/net/ethernet/sunplus/

SUNPLUS OCOTP DRIVER
M:	Vincent Shih <vincent.sunplus@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/nvmem/sunplus,sp7021-ocotp.yaml
F:	drivers/nvmem/sunplus-ocotp.c

SUNPLUS PWM DRIVER
M:	Hammer Hsieh <hammerh0314@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/pwm/sunplus,sp7021-pwm.yaml
F:	drivers/pwm/pwm-sunplus.c

SUNPLUS RTC DRIVER
M:	Vincent Shih <vincent.sunplus@gmail.com>
L:	linux-rtc@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/rtc/sunplus,sp7021-rtc.yaml
F:	drivers/rtc/rtc-sunplus.c

SUNPLUS SPI CONTROLLER INTERFACE DRIVER
M:	Li-hao Kuo <lhjeff911@gmail.com>
L:	linux-spi@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/spi/spi-sunplus-sp7021.yaml
F:	drivers/spi/spi-sunplus-sp7021.c

SUNPLUS UART DRIVER
M:	Hammer Hsieh <hammerh0314@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/serial/sunplus,sp7021-uart.yaml
F:	drivers/tty/serial/sunplus-uart.c

SUNPLUS WATCHDOG DRIVER
M:	Xiantao Hu <xt.hu@cqplus1.com>
L:	linux-watchdog@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/watchdog/sunplus,sp7021-wdt.yaml
F:	drivers/watchdog/sunplus_wdt.c

SUPERH
M:	Yoshinori Sato <ysato@users.sourceforge.jp>
M:	Rich Felker <dalias@libc.org>
L:	linux-sh@vger.kernel.org
S:	Maintained
Q:	http://patchwork.kernel.org/project/linux-sh/list/
F:	Documentation/sh/
F:	arch/sh/
F:	drivers/sh/

SUSPEND TO RAM
M:	"Rafael J. Wysocki" <rafael@kernel.org>
M:	Len Brown <len.brown@intel.com>
M:	Pavel Machek <pavel@ucw.cz>
L:	linux-pm@vger.kernel.org
S:	Supported
B:	https://bugzilla.kernel.org
F:	Documentation/power/
F:	arch/x86/kernel/acpi/
F:	drivers/base/power/
F:	include/linux/freezer.h
F:	include/linux/pm.h
F:	include/linux/suspend.h
F:	kernel/power/

SVGA HANDLING
M:	Martin Mares <mj@ucw.cz>
L:	linux-video@atrey.karlin.mff.cuni.cz
S:	Maintained
F:	Documentation/admin-guide/svga.rst
F:	arch/x86/boot/video*

SWIOTLB SUBSYSTEM
M:	Christoph Hellwig <hch@infradead.org>
L:	iommu@lists.linux.dev
S:	Supported
W:	http://git.infradead.org/users/hch/dma-mapping.git
T:	git git://git.infradead.org/users/hch/dma-mapping.git
F:	arch/*/kernel/pci-swiotlb.c
F:	include/linux/swiotlb.h
F:	kernel/dma/swiotlb.c

SWITCHDEV
M:	Jiri Pirko <jiri@resnulli.us>
M:	Ivan Vecera <ivecera@redhat.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	include/net/switchdev.h
F:	net/switchdev/

SY8106A REGULATOR DRIVER
M:	Icenowy Zheng <icenowy@aosc.io>
S:	Maintained
F:	Documentation/devicetree/bindings/regulator/silergy,sy8106a.yaml
F:	drivers/regulator/sy8106a-regulator.c

SYNC FILE FRAMEWORK
M:	Sumit Semwal <sumit.semwal@linaro.org>
R:	Gustavo Padovan <gustavo@padovan.org>
L:	linux-media@vger.kernel.org
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/driver-api/sync_file.rst
F:	drivers/dma-buf/dma-fence*
F:	drivers/dma-buf/sw_sync.c
F:	drivers/dma-buf/sync_*
F:	include/linux/sync_file.h
F:	include/uapi/linux/sync_file.h

SYNOPSYS ARC ARCHITECTURE
M:	Vineet Gupta <vgupta@kernel.org>
L:	linux-snps-arc@lists.infradead.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/vgupta/arc.git
F:	Documentation/arc/
F:	Documentation/devicetree/bindings/arc/*
F:	Documentation/devicetree/bindings/interrupt-controller/snps,arc*
F:	arch/arc/
F:	drivers/clocksource/arc_timer.c
F:	drivers/tty/serial/arc_uart.c

SYNOPSYS ARC HSDK SDP pll clock driver
M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S:	Supported
F:	Documentation/devicetree/bindings/clock/snps,hsdk-pll-clock.txt
F:	drivers/clk/clk-hsdk-pll.c

SYNOPSYS ARC SDP clock driver
M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S:	Supported
F:	Documentation/devicetree/bindings/clock/snps,pll-clock.txt
F:	drivers/clk/axs10x/*

SYNOPSYS ARC SDP platform support
M:	Alexey Brodkin <abrodkin@synopsys.com>
S:	Supported
F:	Documentation/devicetree/bindings/arc/axs10*
F:	arch/arc/boot/dts/ax*
F:	arch/arc/plat-axs10x

SYNOPSYS AXS10x RESET CONTROLLER DRIVER
M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S:	Supported
F:	Documentation/devicetree/bindings/reset/snps,axs10x-reset.yaml
F:	drivers/reset/reset-axs10x.c

SYNOPSYS CREG GPIO DRIVER
M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S:	Maintained
F:	Documentation/devicetree/bindings/gpio/snps,creg-gpio.txt
F:	drivers/gpio/gpio-creg-snps.c

SYNOPSYS DESIGNWARE 8250 UART DRIVER
R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
S:	Maintained
F:	drivers/tty/serial/8250/8250_dw.c
F:	drivers/tty/serial/8250/8250_dwlib.*
F:	drivers/tty/serial/8250/8250_lpss.c

SYNOPSYS DESIGNWARE APB GPIO DRIVER
M:	Hoan Tran <hoan@os.amperecomputing.com>
M:	Serge Semin <fancer.lancer@gmail.com>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/gpio/snps,dw-apb-gpio.yaml
F:	drivers/gpio/gpio-dwapb.c

SYNOPSYS DESIGNWARE APB SSI DRIVER
M:	Serge Semin <fancer.lancer@gmail.com>
L:	linux-spi@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/spi/snps,dw-apb-ssi.yaml
F:	drivers/spi/spi-dw*

SYNOPSYS DESIGNWARE AXI DMAC DRIVER
M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
S:	Maintained
F:	Documentation/devicetree/bindings/dma/snps,dw-axi-dmac.yaml
F:	drivers/dma/dw-axi-dmac/

SYNOPSYS DESIGNWARE DMAC DRIVER
M:	Viresh Kumar <vireshk@kernel.org>
R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
S:	Maintained
F:	Documentation/devicetree/bindings/dma/renesas,rzn1-dmamux.yaml
F:	Documentation/devicetree/bindings/dma/snps,dma-spear1340.yaml
F:	drivers/dma/dw/
F:	include/dt-bindings/dma/dw-dmac.h
F:	include/linux/dma/dw.h
F:	include/linux/platform_data/dma-dw.h

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 ETHERNET XPCS DRIVER
M:	Jose Abreu <Jose.Abreu@synopsys.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/net/pcs/pcs-xpcs.c
F:	drivers/net/pcs/pcs-xpcs.h
F:	include/linux/pcs/pcs-xpcs.h

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>
R:	Jan Dabros <jsd@semihalf.com>
L:	linux-i2c@vger.kernel.org
S:	Supported
F:	drivers/i2c/busses/i2c-designware-*

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:	Documentation/devicetree/bindings/reset/snps,hsdk-reset.txt
F:	drivers/reset/reset-hsdk.c
F:	include/dt-bindings/reset/snps,hsdk-reset.h

SYNOPSYS SDHCI COMPLIANT DWC MSHC DRIVER
M:	Prabu Thangamuthu <prabu.t@synopsys.com>
M:	Manjunath M B <manjumb@synopsys.com>
L:	linux-mmc@vger.kernel.org
S:	Maintained
F:	drivers/mmc/host/sdhci-pci-dwc-mshc.c

SYSTEM CONFIGURATION (SYSCON)
M:	Lee Jones <lee.jones@linaro.org>
M:	Arnd Bergmann <arnd@arndb.de>
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd.git
F:	drivers/mfd/syscon.c

SYSTEM CONTROL & POWER/MANAGEMENT INTERFACE (SCPI/SCMI) Message Protocol drivers
M:	Sudeep Holla <sudeep.holla@arm.com>
R:	Cristian Marussi <cristian.marussi@arm.com>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/firmware/arm,sc[mp]i.yaml
F:	drivers/clk/clk-sc[mp]i.c
F:	drivers/cpufreq/sc[mp]i-cpufreq.c
F:	drivers/firmware/arm_scmi/
F:	drivers/firmware/arm_scpi.c
F:	drivers/regulator/scmi-regulator.c
F:	drivers/reset/reset-scmi.c
F:	include/linux/sc[mp]i_protocol.h
F:	include/trace/events/scmi.h
F:	include/uapi/linux/virtio_scmi.h

SYSTEM RESET/SHUTDOWN DRIVERS
M:	Sebastian Reichel <sre@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-power-supply.git
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.rst
F:	drivers/hwtracing/stm/
F:	include/linux/stm.h
F:	include/uapi/linux/stm.h

SYSTEM76 ACPI DRIVER
M:	Jeremy Soller <jeremy@system76.com>
M:	System76 Product Development <productdev@system76.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/system76_acpi.c

SYSV FILESYSTEM
M:	Christoph Hellwig <hch@infradead.org>
S:	Maintained
F:	Documentation/filesystems/sysv-fs.rst
F:	fs/sysv/
F:	include/linux/sysv_fs.h

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/
F:	tools/testing/selftests/tc-testing

TC90522 MEDIA DRIVER
M:	Akihiro Tsukada <tskd08@gmail.com>
L:	linux-media@vger.kernel.org
S:	Odd Fixes
F:	drivers/media/dvb-frontends/tc90522*

TCP LOW PRIORITY MODULE
M:	"Wong Hoi Sing, Edison" <hswong3i@gmail.com>
M:	"Hung Hing Lun, Mike" <hlhung3i@gmail.com>
S:	Maintained
W:	http://tcp-lp-mod.sourceforge.net/
F:	net/ipv4/tcp_lp.c

TDA10071 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/dvb-frontends/tda10071*

TDA18212 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/tuners/tda18212*

TDA18218 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/tuners/tda18218*

TDA18250 MEDIA DRIVER
M:	Olli Salonen <olli.salonen@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/tuners/tda18250*

TDA18271 MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/tuners/tda18271*

TDA1997x MEDIA DRIVER
M:	Tim Harvey <tharvey@gateworks.com>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
F:	drivers/media/i2c/tda1997x.*

TDA827x MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/tuners/tda8290.*

TDA8290 MEDIA DRIVER
M:	Michael Krufky <mkrufky@linuxtv.org>
L:	linux-media@vger.kernel.org
S:	Maintained
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
F:	drivers/media/tuners/tda8290.*

TDA9840 MEDIA DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/tda9840*

TEA5761 TUNER DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
S:	Odd fixes
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/tuners/tea5761.*

TEA5767 TUNER DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/tuners/tea5767.*

TEA6415C MEDIA DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/i2c/tea6415c*

TEA6420 MEDIA DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
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>
R:	Sumit Garg <sumit.garg@linaro.org>
L:	op-tee@lists.trustedfirmware.org
S:	Maintained
F:	Documentation/staging/tee.rst
F:	drivers/tee/
F:	include/linux/tee_drv.h
F:	include/uapi/linux/tee.h

TEGRA ARCHITECTURE SUPPORT
M:	Thierry Reding <thierry.reding@gmail.com>
M:	Jonathan Hunter <jonathanh@nvidia.com>
L:	linux-tegra@vger.kernel.org
S:	Supported
Q:	http://patchwork.ozlabs.org/project/linux-tegra/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tegra/linux.git
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>
R:	Dmitry Osipenko <digetx@gmail.com>
S:	Supported
F:	drivers/i2c/busses/i2c-tegra.c

TEGRA IOMMU DRIVERS
M:	Thierry Reding <thierry.reding@gmail.com>
R:	Krishna Reddy <vdumpa@nvidia.com>
L:	linux-tegra@vger.kernel.org
S:	Supported
F:	drivers/iommu/arm/arm-smmu/arm-smmu-nvidia.c
F:	drivers/iommu/tegra*

TEGRA KBC DRIVER
M:	Laxman Dewangan <ldewangan@nvidia.com>
S:	Supported
F:	drivers/input/keyboard/tegra-kbc.c

TEGRA NAND DRIVER
M:	Stefan Agner <stefan@agner.ch>
M:	Lucas Stach <dev@lynxeye.de>
S:	Maintained
F:	Documentation/devicetree/bindings/mtd/nvidia-tegra20-nand.txt
F:	drivers/mtd/nand/raw/tegra_nand.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*

TEGRA QUAD SPI DRIVER
M:	Thierry Reding <thierry.reding@gmail.com>
M:	Jonathan Hunter <jonathanh@nvidia.com>
M:	Sowjanya Komatineni <skomatineni@nvidia.com>
L:	linux-tegra@vger.kernel.org
S:	Maintained
F:	drivers/spi/spi-tegra210-quad.c

TEGRA VIDEO DRIVER
M:	Thierry Reding <thierry.reding@gmail.com>
M:	Jonathan Hunter <jonathanh@nvidia.com>
M:	Sowjanya Komatineni <skomatineni@nvidia.com>
L:	linux-media@vger.kernel.org
L:	linux-tegra@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/display/tegra/nvidia,tegra20-host1x.yaml
F:	drivers/staging/media/tegra-video/

TEGRA XUSB PADCTL DRIVER
M:	JC Kuo <jckuo@nvidia.com>
S:	Supported
F:	drivers/phy/tegra/xusb*

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 <markgross@kernel.org>
S:	Supported
F:	drivers/char/tlclk.c

TEMPO SEMICONDUCTOR DRIVERS
M:	Steven Eckhoff <steven.eckhoff.opensource@gmail.com>
S:	Maintained
F:	Documentation/devicetree/bindings/sound/tscs*.txt
F:	sound/soc/codecs/tscs*.c
F:	sound/soc/codecs/tscs*.h

TENSILICA XTENSA PORT (xtensa)
M:	Chris Zankel <chris@zankel.net>
M:	Max Filippov <jcmvbkbc@gmail.com>
L:	linux-xtensa@linux-xtensa.org
S:	Maintained
T:	git git://github.com/czankel/xtensa-linux.git
F:	arch/xtensa/
F:	drivers/irqchip/irq-xtensa-*

TEXAS INSTRUMENTS ASoC DRIVERS
M:	Peter Ujfalusi <peter.ujfalusi@gmail.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/sound/davinci-mcasp-audio.yaml
F:	sound/soc/ti/

TEXAS INSTRUMENTS' DAC7612 DAC DRIVER
M:	Ricardo Ribalda <ribalda@kernel.org>
L:	linux-iio@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/iio/dac/ti,dac7612.yaml
F:	drivers/iio/dac/ti-dac7612.c

TEXAS INSTRUMENTS DMA DRIVERS
M:	Peter Ujfalusi <peter.ujfalusi@gmail.com>
L:	dmaengine@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/dma/ti-dma-crossbar.txt
F:	Documentation/devicetree/bindings/dma/ti-edma.txt
F:	Documentation/devicetree/bindings/dma/ti/
F:	drivers/dma/ti/
X:	drivers/dma/ti/cppi41.c
F:	include/linux/dma/k3-udma-glue.h
F:	include/linux/dma/ti-cppi5.h
F:	include/linux/dma/k3-psil.h

TEXAS INSTRUMENTS' SYSTEM CONTROL INTERFACE (TISCI) PROTOCOL DRIVER
M:	Nishanth Menon <nm@ti.com>
M:	Tero Kristo <kristo@kernel.org>
M:	Santosh Shilimkar <ssantosh@kernel.org>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/arm/keystone/ti,k3-sci-common.yaml
F:	Documentation/devicetree/bindings/arm/keystone/ti,sci.yaml
F:	Documentation/devicetree/bindings/clock/ti,sci-clk.yaml
F:	Documentation/devicetree/bindings/interrupt-controller/ti,sci-inta.yaml
F:	Documentation/devicetree/bindings/interrupt-controller/ti,sci-intr.yaml
F:	Documentation/devicetree/bindings/reset/ti,sci-reset.yaml
F:	Documentation/devicetree/bindings/soc/ti/sci-pm-domain.yaml
F:	drivers/clk/keystone/sci-clk.c
F:	drivers/firmware/ti_sci*
F:	drivers/irqchip/irq-ti-sci-inta.c
F:	drivers/irqchip/irq-ti-sci-intr.c
F:	drivers/reset/reset-ti-sci.c
F:	drivers/soc/ti/ti_sci_inta_msi.c
F:	drivers/soc/ti/ti_sci_pm_domains.c
F:	include/dt-bindings/soc/ti,sci_pm_domain.h
F:	include/linux/soc/ti/ti_sci_inta_msi.h
F:	include/linux/soc/ti/ti_sci_protocol.h

TEXAS INSTRUMENTS TPS23861 PoE PSE DRIVER
M:	Robert Marko <robert.marko@sartura.hr>
M:	Luka Perkov <luka.perkov@sartura.hr>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/hwmon/ti,tps23861.yaml
F:	Documentation/hwmon/tps23861.rst
F:	drivers/hwmon/tps23861.c

TEXAS INSTRUMENTS' TMP117 TEMPERATURE SENSOR DRIVER
M:	Puranjay Mohan <puranjay12@gmail.com>
L:	linux-iio@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/iio/temperature/ti,tmp117.yaml
F:	drivers/iio/temperature/tmp117.c

THANKO'S RAREMONO AM/FM/SW RADIO RECEIVER USB DRIVER
M:	Hans Verkuil <hverkuil@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/radio/radio-raremono.c

THERMAL
M:	Rafael J. Wysocki <rafael@kernel.org>
M:	Daniel Lezcano <daniel.lezcano@linaro.org>
R:	Amit Kucheria <amitk@kernel.org>
R:	Zhang Rui <rui.zhang@intel.com>
L:	linux-pm@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-pm/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm.git thermal
F:	Documentation/ABI/testing/sysfs-class-thermal
F:	Documentation/devicetree/bindings/thermal/
F:	Documentation/driver-api/thermal/
F:	drivers/thermal/
F:	include/dt-bindings/thermal/
F:	include/linux/cpu_cooling.h
F:	include/linux/thermal.h
F:	include/uapi/linux/thermal.h
F:	tools/lib/thermal/
F:	tools/thermal/

THERMAL DRIVER FOR AMLOGIC SOCS
M:	Guillaume La Roque <glaroque@baylibre.com>
L:	linux-pm@vger.kernel.org
L:	linux-amlogic@lists.infradead.org
S:	Supported
W:	http://linux-meson.com/
F:	Documentation/devicetree/bindings/thermal/amlogic,thermal.yaml
F:	drivers/thermal/amlogic_thermal.c

THERMAL/CPU_COOLING
M:	Amit Daniel Kachhap <amit.kachhap@gmail.com>
M:	Daniel Lezcano <daniel.lezcano@linaro.org>
M:	Viresh Kumar <viresh.kumar@linaro.org>
R:	Lukasz Luba <lukasz.luba@arm.com>
L:	linux-pm@vger.kernel.org
S:	Supported
F:	Documentation/driver-api/thermal/cpu-cooling-api.rst
F:	Documentation/driver-api/thermal/cpu-idle-cooling.rst
F:	drivers/thermal/cpufreq_cooling.c
F:	drivers/thermal/cpuidle_cooling.c
F:	include/linux/cpu_cooling.h

THERMAL/POWER_ALLOCATOR
M:	Lukasz Luba <lukasz.luba@arm.com>
L:	linux-pm@vger.kernel.org
S:	Maintained
F:	Documentation/driver-api/thermal/power_allocator.rst
F:	drivers/thermal/gov_power_allocator.c
F:	include/trace/events/thermal_power_allocator.h

THINKPAD ACPI EXTRAS DRIVER
M:	Henrique de Moraes Holschuh <hmh@hmh.eng.br>
L:	ibm-acpi-devel@lists.sourceforge.net
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
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
F:	drivers/platform/x86/thinkpad_acpi.c

THINKPAD LMI DRIVER
M:	Mark Pearson <markpearson@lenovo.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-class-firmware-attributes
F:	drivers/platform/x86/think-lmi.?

THUNDERBOLT DMA TRAFFIC TEST DRIVER
M:	Isaac Hazan <isaac.hazan@intel.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/thunderbolt/dma_test.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>
L:	linux-usb@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/westeri/thunderbolt.git
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:	Robert Richter <rric@kernel.org>
S:	Odd Fixes
F:	drivers/gpio/gpio-thunderx.c

TI ADS131E0X ADC SERIES DRIVER
M:	Tomislav Denis <tomislav.denis@avl.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/adc/ti,ads131e08.yaml
F:	drivers/iio/adc/ti-ads131e08.c

TI AM437X VPFE DRIVER
M:	"Lad, Prabhakar" <prabhakar.csengg@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mhadli/v4l-dvb-davinci_devices.git
F:	drivers/media/platform/ti/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
F:	drivers/power/supply/bq27xxx_battery.c
F:	drivers/power/supply/bq27xxx_battery_i2c.c
F:	include/linux/power/bq27xxx_battery.h

TI CDCE706 CLOCK DRIVER
M:	Max Filippov <jcmvbkbc@gmail.com>
S:	Maintained
F:	drivers/clk/clk-cdce706.c

TI CLOCK DRIVER
M:	Tero Kristo <kristo@kernel.org>
L:	linux-omap@vger.kernel.org
S:	Odd Fixes
F:	drivers/clk/ti/
F:	include/linux/clk/ti.h

TI DAVINCI MACHINE SUPPORT
M:	Sekhar Nori <nsekhar@ti.com>
R:	Bartosz Golaszewski <brgl@bgdev.pl>
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/nsekhar/linux-davinci.git
F:	Documentation/devicetree/bindings/i2c/i2c-davinci.txt
F:	arch/arm/boot/dts/da850*
F:	arch/arm/mach-davinci/
F:	drivers/i2c/busses/i2c-davinci.c

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.yaml
F:	drivers/gpio/gpio-davinci.c

TI DAVINCI SERIES MEDIA DRIVER
M:	"Lad, Prabhakar" <prabhakar.csengg@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
T:	git git://linuxtv.org/mhadli/v4l-dvb-davinci_devices.git
F:	drivers/media/platform/ti/davinci/
F:	include/media/davinci/

TI ENHANCED QUADRATURE ENCODER PULSE (eQEP) DRIVER
R:	David Lechner <david@lechnology.com>
L:	linux-iio@vger.kernel.org
F:	Documentation/devicetree/bindings/counter/ti-eqep.yaml
F:	drivers/counter/ti-eqep.c

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 MEMORYSTICK/MMC DRIVERS
M:	Alex Dubov <oakad@yahoo.com>
S:	Maintained
W:	http://tifmxx.berlios.de/
F:	drivers/memstick/host/tifm_ms.c
F:	drivers/misc/tifm*
F:	drivers/mmc/host/tifm_sd.c
F:	include/linux/tifm.h

TI KEYSTONE MULTICORE NAVIGATOR DRIVERS
M:	Nishanth Menon <nm@ti.com>
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
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/ti/linux.git
F:	drivers/soc/ti/*

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/isabelle*
F:	sound/soc/codecs/lm49453*

TI PCM3060 ASoC CODEC DRIVER
M:	Kirill Marinushkin <kmarinushkin@birdec.com>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	Documentation/devicetree/bindings/sound/pcm3060.txt
F:	sound/soc/codecs/pcm3060*

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 (subscribers-only)
S:	Supported
F:	Documentation/devicetree/bindings/net/nfc/ti,trf7970a.yaml
F:	drivers/nfc/trf7970a.c

TI TSC2046 ADC DRIVER
M:	Oleksij Rempel <o.rempel@pengutronix.de>
R:	kernel@pengutronix.de
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/adc/ti,tsc2046.yaml
F:	drivers/iio/adc/ti-tsc2046.c

TI TWL4030 SERIES SOC CODEC DRIVER
M:	Peter Ujfalusi <peter.ujfalusi@gmail.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
S:	Maintained
W:	http://linuxtv.org/
Q:	http://patchwork.linuxtv.org/project/linux-media/list/
F:	Documentation/devicetree/bindings/media/ti,cal.yaml
F:	Documentation/devicetree/bindings/media/ti,vpe.yaml
F:	drivers/media/platform/ti/cal/
F:	drivers/media/platform/ti/vpe/

TI WILINK WIRELESS DRIVERS
L:	linux-wireless@vger.kernel.org
S:	Orphan
W:	https://wireless.wiki.kernel.org/en/users/Drivers/wl12xx
W:	https://wireless.wiki.kernel.org/en/users/Drivers/wl1251
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/luca/wl12xx.git
F:	drivers/net/wireless/ti/
F:	include/linux/wl12xx.h

TIMEKEEPING, CLOCKSOURCE CORE, NTP, ALARMTIMER
M:	John Stultz <jstultz@google.com>
M:	Thomas Gleixner <tglx@linutronix.de>
R:	Stephen Boyd <sboyd@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git timers/core
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/alarmtimer.c
F:	kernel/time/clocksource.c
F:	kernel/time/ntp.c
F:	kernel/time/time*.c
F:	tools/testing/selftests/timers/

TIPC NETWORK LAYER
M:	Jon Maloy <jmaloy@redhat.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)
S:	Maintained
W:	http://tipc.sourceforge.net/
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)
S:	Maintained
W:	http://sourceforge.net/projects/tlan/
F:	Documentation/networking/device_drivers/ethernet/ti/tlan.rst
F:	drivers/net/ethernet/ti/tlan.*

TM6000 VIDEO4LINUX DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
S:	Odd fixes
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/admin-guide/media/tm6000*
F:	drivers/media/usb/tm6000/

TMIO/SDHI MMC DRIVER
M:	Wolfram Sang <wsa+renesas@sang-engineering.com>
L:	linux-mmc@vger.kernel.org
L:	linux-renesas-soc@vger.kernel.org
S:	Supported
F:	drivers/mmc/host/renesas_sdhi*
F:	drivers/mmc/host/tmio_mmc*
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/devicetree/bindings/hwmon/ti,tmp401.yaml
F:	Documentation/hwmon/tmp401.rst
F:	drivers/hwmon/tmp401.c

TMP464 HARDWARE MONITOR DRIVER
M:	Agathe Porte <agathe.porte@nokia.com>
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/hwmon/ti,tmp464.yaml
F:	Documentation/hwmon/tmp464.rst
F:	drivers/hwmon/tmp464.c

TMP513 HARDWARE MONITOR DRIVER
M:	Eric Tremblay <etremblay@distech-controls.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/tmp513.rst
F:	drivers/hwmon/tmp513.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.osdn.me (subscribers-only, for developers in English)
L:	tomoyo-users-en@lists.osdn.me (subscribers-only, for users in English)
L:	tomoyo-dev@lists.osdn.me (subscribers-only, for developers in Japanese)
L:	tomoyo-users@lists.osdn.me (subscribers-only, for users in Japanese)
S:	Maintained
W:	https://tomoyo.osdn.jp/
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@kernel.org>
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 dev
F:	Documentation/RCU/torture.rst
F:	kernel/locking/locktorture.c
F:	kernel/rcu/rcuscale.c
F:	kernel/rcu/rcutorture.c
F:	kernel/rcu/refscale.c
F:	kernel/torture.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>
S:	Maintained
W:	http://www.buzzard.org.uk/toshiba/
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@kernel.org>
R:	Jason Gunthorpe <jgg@ziepe.ca>
L:	linux-integrity@vger.kernel.org
S:	Maintained
W:	https://kernsec.org/wiki/index.php/Linux_Kernel_Integrity
Q:	https://patchwork.kernel.org/project/linux-integrity/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd.git
F:	drivers/char/tpm/

TRACING
M:	Steven Rostedt <rostedt@goodmis.org>
M:	Ingo Molnar <mingo@redhat.com>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
F:	Documentation/trace/ftrace.rst
F:	arch/*/*/*/*ftrace*
F:	arch/*/*/*ftrace*
F:	fs/tracefs/
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>
L:	linux-kernel@vger.kernel.org
L:	nouveau@lists.freedesktop.org
S:	Maintained
F:	arch/x86/mm/kmmio.c
F:	arch/x86/mm/mmio-mod.c
F:	arch/x86/mm/testmmiotrace.c
F:	include/linux/mmiotrace.h
F:	kernel/trace/trace_mmiotrace.c

TRACING OS NOISE / LATENCY TRACERS
M:	Steven Rostedt <rostedt@goodmis.org>
M:	Daniel Bristot de Oliveira <bristot@kernel.org>
S:	Maintained
F:	kernel/trace/trace_osnoise.c
F:	include/trace/events/osnoise.h
F:	kernel/trace/trace_hwlat.c
F:	kernel/trace/trace_irqsoff.c
F:	kernel/trace/trace_sched_wakeup.c
F:	Documentation/trace/osnoise-tracer.rst
F:	Documentation/trace/timerlat-tracer.rst
F:	Documentation/trace/hwlat_detector.rst
F:	arch/*/kernel/trace.c

Real-time Linux Analysis (RTLA) tools
M:	Daniel Bristot de Oliveira <bristot@kernel.org>
M:	Steven Rostedt <rostedt@goodmis.org>
L:	linux-trace-devel@vger.kernel.org
S:	Maintained
F:	Documentation/tools/rtla/
F:	tools/tracing/rtla/

TRADITIONAL CHINESE DOCUMENTATION
M:	Hu Haowen <src.res@email.cn>
L:	linux-doc-tw-discuss@lists.sourceforge.net (moderated for non-subscribers)
S:	Maintained
W:	https://github.com/srcres258/linux-doc
T:	git git://github.com/srcres258/linux-doc.git doc-zh-tw
F:	Documentation/translations/zh_TW/

TTY LAYER
M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
M:	Jiri Slaby <jirislaby@kernel.org>
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty.git
F:	Documentation/driver-api/serial/
F:	drivers/tty/
F:	drivers/tty/serial/serial_core.c
F:	include/linux/selection.h
F:	include/linux/serial.h
F:	include/linux/serial_core.h
F:	include/linux/sysrq.h
F:	include/linux/tty*.h
F:	include/linux/vt.h
F:	include/linux/vt_*.h
F:	include/uapi/linux/serial.h
F:	include/uapi/linux/serial_core.h
F:	include/uapi/linux/tty.h

TUA9001 MEDIA DRIVER
M:	Antti Palosaari <crope@iki.fi>
L:	linux-media@vger.kernel.org
S:	Maintained
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
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>
S:	Maintained
W:	http://vtun.sourceforge.net/tun
F:	Documentation/networking/tuntap.rst
F:	arch/um/os-Linux/drivers/

TURBOCHANNEL SUBSYSTEM
M:	"Maciej W. Rozycki" <macro@orcam.me.uk>
M:	Ralf Baechle <ralf@linux-mips.org>
L:	linux-mips@vger.kernel.org
S:	Maintained
Q:	http://patchwork.linux-mips.org/project/linux-mips/list/
F:	drivers/tc/
F:	include/linux/tc.h

TURBOSTAT UTILITY
M:	"Len Brown" <lenb@kernel.org>
L:	linux-pm@vger.kernel.org
S:	Supported
Q:	https://patchwork.kernel.org/project/linux-pm/list/
B:	https://bugzilla.kernel.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux.git turbostat
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
S:	Odd Fixes
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/pci/tw68/

TW686X VIDEO4LINUX DRIVER
M:	Ezequiel Garcia <ezequiel@vanguardiasur.com.ar>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	http://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/pci/tw686x/

U-BOOT ENVIRONMENT VARIABLES
M:	Rafał Miłecki <rafal@milecki.pl>
S:	Maintained
F:	Documentation/devicetree/bindings/nvmem/u-boot,env.yaml

UACCE ACCELERATOR FRAMEWORK
M:	Zhangfei Gao <zhangfei.gao@linaro.org>
M:	Zhou Wang <wangzhou1@hisilicon.com>
L:	linux-accelerators@lists.ozlabs.org
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-driver-uacce
F:	Documentation/misc-devices/uacce.rst
F:	drivers/misc/uacce/
F:	include/linux/uacce.h
F:	include/uapi/misc/uacce/

UBI FILE SYSTEM (UBIFS)
M:	Richard Weinberger <richard@nod.at>
L:	linux-mtd@lists.infradead.org
S:	Supported
W:	http://www.linux-mtd.infradead.org/doc/ubifs.html
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rw/ubifs.git next
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rw/ubifs.git fixes
F:	Documentation/ABI/testing/sysfs-fs-ubifs
F:	Documentation/filesystems/ubifs-authentication.rst
F:	Documentation/filesystems/ubifs.rst
F:	fs/ubifs/

UBLK USERSPACE BLOCK DRIVER
M:	Ming Lei <ming.lei@redhat.com>
L:	linux-block@vger.kernel.org
S:	Maintained
F:	drivers/block/ublk_drv.c
F:	include/uapi/linux/ublk_cmd.h

UCLINUX (M68KNOMMU AND COLDFIRE)
M:	Greg Ungerer <gerg@linux-m68k.org>
L:	linux-m68k@lists.linux-m68k.org
L:	uclinux-dev@uclinux.org  (subscribers-only)
S:	Maintained
W:	http://www.linux-m68k.org/
W:	http://www.uclinux.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gerg/m68knommu.git
F:	arch/m68k/*/*_no.*
F:	arch/m68k/68*/
F:	arch/m68k/coldfire/
F:	arch/m68k/include/asm/*_no.*

UDF FILESYSTEM
M:	Jan Kara <jack@suse.com>
S:	Maintained
F:	Documentation/filesystems/udf.rst
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/admin-guide/ufs.rst
F:	fs/ufs/

UHID USERSPACE HID IO DRIVER
M:	David Rheinsberg <david.rheinsberg@gmail.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/

UNICODE SUBSYSTEM
M:	Gabriel Krisman Bertazi <krisman@collabora.com>
L:	linux-fsdevel@vger.kernel.org
S:	Supported
F:	fs/unicode/

UNIFDEF
M:	Tony Finch <dot@dotat.at>
S:	Maintained
W:	http://dotat.at/prog/unifdef
F:	scripts/unifdef.c

UNIFORM CDROM DRIVER
M:	Phillip Potter <phil@philpotter.co.uk>
S:	Maintained
F:	Documentation/cdrom/
F:	drivers/cdrom/cdrom.c
F:	include/linux/cdrom.h
F:	include/uapi/linux/cdrom.h

UNIVERSAL FLASH STORAGE HOST CONTROLLER DRIVER
R:	Alim Akhtar <alim.akhtar@samsung.com>
R:	Avri Altman <avri.altman@wdc.com>
R:	Bart Van Assche <bvanassche@acm.org>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/ufs/
F:	Documentation/scsi/ufs.rst
F:	drivers/ufs/core/

UNIVERSAL FLASH STORAGE HOST CONTROLLER DRIVER DWC HOOKS
M:	Pedro Sousa <pedrom.sousa@synopsys.com>
L:	linux-scsi@vger.kernel.org
S:	Supported
F:	drivers/ufs/host/*dwc*

UNIVERSAL FLASH STORAGE HOST CONTROLLER DRIVER MEDIATEK HOOKS
M:	Stanley Chu <stanley.chu@mediatek.com>
L:	linux-scsi@vger.kernel.org
L:	linux-mediatek@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/ufs/host/ufs-mediatek*

UNIVERSAL FLASH STORAGE HOST CONTROLLER DRIVER RENESAS HOOKS
M:	Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
L:	linux-renesas-soc@vger.kernel.org
L:	linux-scsi@vger.kernel.org
S:	Maintained
F:	drivers/ufs/host/ufs-renesas.c

UNSORTED BLOCK IMAGES (UBI)
M:	Richard Weinberger <richard@nod.at>
L:	linux-mtd@lists.infradead.org
S:	Supported
W:	http://www.linux-mtd.infradead.org/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rw/ubifs.git next
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/rw/ubifs.git fixes
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
S:	Maintained
W:	http://www.linux-usb.org/usbnet
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.rst
F:	drivers/usb/class/cdc-acm.*

USB APPLE MFI FASTCHARGE DRIVER
M:	Bastien Nocera <hadess@hadess.net>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/misc/apple-mfi-fastcharge.c

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
L:	linux-usb@vger.kernel.org
S:	Orphan
F:	drivers/usb/c67x00/

USB DAVICOM DM9601 DRIVER
M:	Peter Korsgaard <peter@korsgaard.com>
L:	netdev@vger.kernel.org
S:	Maintained
W:	http://www.linux-usb.org/usbnet
F:	drivers/net/usb/dm9601.c

USB EHCI DRIVER
M:	Alan Stern <stern@rowland.harvard.edu>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/usb/ehci.rst
F:	drivers/usb/host/ehci*

USB GADGET/PERIPHERAL SUBSYSTEM
M:	Felipe Balbi <balbi@kernel.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
W:	http://www.linux-usb.org/gadget
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb.git
F:	drivers/usb/gadget/
F:	include/linux/usb/gadget*

USB HID/HIDBP DRIVERS (USB KEYBOARDS, MICE, REMOTE CONTROLS, ...)
M:	Jiri Kosina <jikos@kernel.org>
M:	Benjamin Tissoires <benjamin.tissoires@redhat.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid.git
F:	Documentation/hid/hiddev.rst
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 IP DRIVER FOR HISILICON KIRIN 960
M:	Yu Chen <chenyu56@huawei.com>
M:	Binghui Wang <wangbinghui@hisilicon.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/phy/hisilicon,hi3660-usb3.yaml
F:	drivers/phy/hisilicon/phy-hi3660-usb3.c

USB IP DRIVER FOR HISILICON KIRIN 970
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/phy/hisilicon,hi3670-usb3.yaml
F:	drivers/phy/hisilicon/phy-hi3670-usb3.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 ISP1760 DRIVER
M:	Rui Miguel Silva <rui.silva@linaro.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/isp1760/*
F:	Documentation/devicetree/bindings/usb/nxp,isp1760.yaml

USB LAN78XX ETHERNET DRIVER
M:	Woojung Huh <woojung.huh@microchip.com>
M:	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
F:	drivers/usb/storage/

USB MIDI DRIVER
M:	Clemens Ladisch <clemens@ladisch.de>
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
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.rst
F:	drivers/usb/host/ohci*

USB OTG FSM (Finite State Machine)
M:	Peter Chen <peter.chen@kernel.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/peter.chen/usb.git
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>
M:	Shuah Khan <skhan@linuxfoundation.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/usb/usbip_protocol.rst
F:	drivers/usb/usbip/
F:	tools/testing/selftests/drivers/usb/usbip/
F:	tools/usb/usbip/

USB PEGASUS DRIVER
M:	Petko Manolov <petkan@nucleusys.com>
L:	linux-usb@vger.kernel.org
L:	netdev@vger.kernel.org
S:	Maintained
W:	https://github.com/petkan/pegasus
T:	git git://github.com/petkan/pegasus.git
F:	drivers/net/usb/pegasus.*

USB PHY LAYER
M:	Felipe Balbi <balbi@kernel.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb.git
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 RAW GADGET DRIVER
R:	Andrey Konovalov <andreyknvl@gmail.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/usb/raw-gadget.rst
F:	drivers/usb/gadget/legacy/raw_gadget.c
F:	include/uapi/linux/usb/raw_gadget.h

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
S:	Maintained
W:	https://github.com/petkan/rtl8150
T:	git git://github.com/petkan/rtl8150.git
F:	drivers/net/usb/rtl8150.c

USB SERIAL SUBSYSTEM
M:	Johan Hovold <johan@kernel.org>
L:	linux-usb@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/johan/usb-serial.git
F:	Documentation/usb/usb-serial.rst
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:	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
S:	Supported
W:	http://www.linux-usb.org
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb.git
F:	Documentation/devicetree/bindings/usb/
F:	Documentation/usb/
F:	drivers/usb/
F:	include/dt-bindings/usb/
F:	include/linux/usb.h
F:	include/linux/usb/

USB TYPEC BUS FOR ALTERNATE MODES
M:	Heikki Krogerus <heikki.krogerus@linux.intel.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-typec
F:	Documentation/driver-api/usb/typec_bus.rst
F:	drivers/usb/typec/altmodes/
F:	include/linux/usb/typec_altmode.h

USB TYPEC CLASS
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/driver-api/usb/typec.rst
F:	drivers/usb/typec/
F:	include/linux/usb/typec.h

USB TYPEC INTEL PMC MUX DRIVER
M:	Heikki Krogerus <heikki.krogerus@linux.intel.com>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	Documentation/firmware-guide/acpi/intel-pmc-mux.rst
F:	drivers/usb/typec/mux/intel_pmc_mux.c

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 PORT CONTROLLER DRIVERS
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-usb@vger.kernel.org
S:	Maintained
F:	drivers/usb/typec/tcpm/

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-media@vger.kernel.org
S:	Maintained
W:	http://www.ideasonboard.org/uvc/
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/usb/uvc/
F:	include/uapi/linux/uvcvideo.h

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
F:	include/uapi/linux/usb/g_uvc.h

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/pci-quirks*
F:	drivers/usb/host/xhci*

USB ZD1201 DRIVER
L:	linux-wireless@vger.kernel.org
S:	Orphan
W:	http://linux-lc100020.sourceforge.net
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
S:	Maintained
W:	http://royale.zerezo.com/zr364xx/
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/admin-guide/media/zr364xx*
F:	drivers/media/usb/zr364xx/

USER-MODE LINUX (UML)
M:	Richard Weinberger <richard@nod.at>
M:	Anton Ivanov <anton.ivanov@cambridgegreys.com>
M:	Johannes Berg <johannes@sipsolutions.net>
L:	linux-um@lists.infradead.org
S:	Maintained
W:	http://user-mode-linux.sourceforge.net
Q:	https://patchwork.ozlabs.org/project/linux-um/list/
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/uml/linux.git next
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/uml/linux.git fixes
F:	Documentation/virt/uml/
F:	arch/um/
F:	arch/x86/um/
F:	fs/hostfs/

USERSPACE COPYIN/COPYOUT (UIOVEC)
M:	Alexander Viro <viro@zeniv.linux.org.uk>
S:	Maintained
F:	include/linux/uio.h
F:	lib/iov_iter.c

USERSPACE DMA BUFFER DRIVER
M:	Gerd Hoffmann <kraxel@redhat.com>
L:	dri-devel@lists.freedesktop.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	drivers/dma-buf/udmabuf.c
F:	include/uapi/linux/udmabuf.h

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_driver.h

UTIL-LINUX PACKAGE
M:	Karel Zak <kzak@redhat.com>
L:	util-linux@vger.kernel.org
S:	Maintained
W:	http://en.wikipedia.org/wiki/Util-linux
T:	git git://git.kernel.org/pub/scm/utils/util-linux/util-linux.git

UUID HELPERS
M:	Christoph Hellwig <hch@lst.de>
R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.infradead.org/users/hch/uuid.git
F:	include/linux/uuid.h
F:	include/uapi/linux/uuid.h
F:	lib/test_uuid.c
F:	lib/uuid.c

UV SYSFS DRIVER
M:	Justin Ernst <justin.ernst@hpe.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
F:	drivers/platform/x86/uv_sysfs.c

UVESAFB DRIVER
M:	Michal Januszewski <spock@gentoo.org>
L:	linux-fbdev@vger.kernel.org
S:	Maintained
W:	https://github.com/mjanusz/v86d
F:	Documentation/fb/uvesafb.rst
F:	drivers/video/fbdev/uvesafb.*

Ux500 CLOCK DRIVERS
M:	Ulf Hansson <ulf.hansson@linaro.org>
L:	linux-clk@vger.kernel.org
L:	linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S:	Maintained
F:	drivers/clk/ux500/

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.rst
F:	fs/fat/

VFIO DRIVER
M:	Alex Williamson <alex.williamson@redhat.com>
R:	Cornelia Huck <cohuck@redhat.com>
L:	kvm@vger.kernel.org
S:	Maintained
T:	git git://github.com/awilliam/linux-vfio.git
F:	Documentation/driver-api/vfio.rst
F:	drivers/vfio/
F:	include/linux/vfio.h
F:	include/linux/vfio_pci_core.h
F:	include/uapi/linux/vfio.h

VFIO FSL-MC DRIVER
M:	Diana Craciun <diana.craciun@oss.nxp.com>
L:	kvm@vger.kernel.org
S:	Maintained
F:	drivers/vfio/fsl-mc/

VFIO HISILICON PCI DRIVER
M:	Longfang Liu <liulongfang@huawei.com>
M:	Shameer Kolothum <shameerali.kolothum.thodi@huawei.com>
L:	kvm@vger.kernel.org
S:	Maintained
F:	drivers/vfio/pci/hisilicon/

VFIO MEDIATED DEVICE DRIVERS
M:	Kirti Wankhede <kwankhede@nvidia.com>
L:	kvm@vger.kernel.org
S:	Maintained
F:	Documentation/driver-api/vfio-mediated-device.rst
F:	drivers/vfio/mdev/
F:	include/linux/mdev.h
F:	samples/vfio-mdev/

VFIO PCI DEVICE SPECIFIC DRIVERS
R:	Jason Gunthorpe <jgg@nvidia.com>
R:	Yishai Hadas <yishaih@nvidia.com>
R:	Shameer Kolothum <shameerali.kolothum.thodi@huawei.com>
R:	Kevin Tian <kevin.tian@intel.com>
L:	kvm@vger.kernel.org
S:	Maintained
P:	Documentation/driver-api/vfio-pci-device-specific-driver-acceptance.rst
F:	drivers/vfio/pci/*/

VFIO PLATFORM DRIVER
M:	Eric Auger <eric.auger@redhat.com>
L:	kvm@vger.kernel.org
S:	Maintained
F:	drivers/vfio/platform/

VFIO MLX5 PCI DRIVER
M:	Yishai Hadas <yishaih@nvidia.com>
L:	kvm@vger.kernel.org
S:	Maintained
F:	drivers/vfio/pci/mlx5/

VGA_SWITCHEROO
R:	Lukas Wunner <lukas@wunner.de>
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
F:	Documentation/gpu/vga-switcheroo.rst
F:	drivers/gpu/vga/vga_switcheroo.c
F:	include/linux/vga_switcheroo.h

VIA RHINE NETWORK DRIVER
S:	Maintained
M:	Kevin Brace <kevinbrace@bracecomputerlab.com>
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:	drivers/video/fbdev/via/
F:	include/linux/via-core.h
F:	include/linux/via-gpio.h
F:	include/linux/via_i2c.h

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.*

VICODEC VIRTUAL CODEC DRIVER
M:	Hans Verkuil <hverkuil-cisco@xs4all.nl>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/test-drivers/vicodec/*

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

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

VIDEOBUF2 FRAMEWORK
M:	Tomasz Figa <tfiga@chromium.org>
M:	Marek Szyprowski <m.szyprowski@samsung.com>
L:	linux-media@vger.kernel.org
S:	Maintained
F:	drivers/media/common/videobuf2/*
F:	include/media/videobuf2-*

VIMC VIRTUAL MEDIA CONTROLLER DRIVER
M:	Shuah Khan <skhan@linuxfoundation.org>
R:	Kieran Bingham <kieran.bingham@ideasonboard.com>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/test-drivers/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>
M:	Stefano Garzarella <sgarzare@redhat.com>
L:	kvm@vger.kernel.org
L:	virtualization@lists.linux-foundation.org
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/vhost/vsock.c
F:	include/linux/virtio_vsock.h
F:	include/uapi/linux/virtio_vsock.h
F:	net/vmw_vsock/virtio_transport.c
F:	net/vmw_vsock/virtio_transport_common.c

VIRTIO BLOCK AND SCSI DRIVERS
M:	"Michael S. Tsirkin" <mst@redhat.com>
M:	Jason Wang <jasowang@redhat.com>
R:	Paolo Bonzini <pbonzini@redhat.com>
R:	Stefan Hajnoczi <stefanha@redhat.com>
L:	virtualization@lists.linux-foundation.org
S:	Maintained
F:	drivers/block/virtio_blk.c
F:	drivers/scsi/virtio_scsi.c
F:	drivers/vhost/scsi.c
F:	include/uapi/linux/virtio_blk.h
F:	include/uapi/linux/virtio_scsi.h

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 AND NET DRIVERS
M:	"Michael S. Tsirkin" <mst@redhat.com>
M:	Jason Wang <jasowang@redhat.com>
L:	virtualization@lists.linux-foundation.org
S:	Maintained
F:	Documentation/ABI/testing/sysfs-bus-vdpa
F:	Documentation/ABI/testing/sysfs-class-vduse
F:	Documentation/devicetree/bindings/virtio/
F:	drivers/block/virtio_blk.c
F:	drivers/crypto/virtio/
F:	drivers/net/virtio_net.c
F:	drivers/vdpa/
F:	drivers/virtio/
F:	include/linux/vdpa.h
F:	include/linux/virtio*.h
F:	include/uapi/linux/virtio_*.h
F:	tools/virtio/

VIRTIO BALLOON
M:	"Michael S. Tsirkin" <mst@redhat.com>
M:	David Hildenbrand <david@redhat.com>
L:	virtualization@lists.linux-foundation.org
S:	Maintained
F:	drivers/virtio/virtio_balloon.c
F:	include/uapi/linux/virtio_balloon.h
F:	include/linux/balloon_compaction.h
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>
M:	Eric Farman <farman@linux.ibm.com>
L:	linux-s390@vger.kernel.org
L:	virtualization@lists.linux-foundation.org
L:	kvm@vger.kernel.org
S:	Supported
F:	arch/s390/include/uapi/asm/virtio-ccw.h
F:	drivers/s390/virtio/

VIRTIO FILE SYSTEM
M:	Vivek Goyal <vgoyal@redhat.com>
M:	Stefan Hajnoczi <stefanha@redhat.com>
M:	Miklos Szeredi <miklos@szeredi.hu>
L:	virtualization@lists.linux-foundation.org
L:	linux-fsdevel@vger.kernel.org
S:	Supported
W:	https://virtio-fs.gitlab.io/
F:	Documentation/filesystems/virtiofs.rst
F:	fs/fuse/virtio_fs.c
F:	include/uapi/linux/virtio_fs.h

VIRTIO GPIO DRIVER
M:	Enrico Weigelt, metux IT consult <info@metux.net>
M:	Viresh Kumar <vireshk@kernel.org>
L:	linux-gpio@vger.kernel.org
L:	virtualization@lists.linux-foundation.org
S:	Maintained
F:	drivers/gpio/gpio-virtio.c
F:	include/uapi/linux/virtio_gpio.h

VIRTIO GPU DRIVER
M:	David Airlie <airlied@linux.ie>
M:	Gerd Hoffmann <kraxel@redhat.com>
R:	Gurchetan Singh <gurchetansingh@chromium.org>
R:	Chia-I Wu <olvaffe@gmail.com>
L:	dri-devel@lists.freedesktop.org
L:	virtualization@lists.linux-foundation.org
S:	Maintained
T:	git git://anongit.freedesktop.org/drm/drm-misc
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
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost.git
F:	drivers/vhost/
F:	include/linux/vhost_iotlb.h
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

VIRTIO IOMMU DRIVER
M:	Jean-Philippe Brucker <jean-philippe@linaro.org>
L:	virtualization@lists.linux-foundation.org
S:	Maintained
F:	drivers/iommu/virtio-iommu.c
F:	include/uapi/linux/virtio_iommu.h

VIRTIO MEM DRIVER
M:	David Hildenbrand <david@redhat.com>
L:	virtualization@lists.linux-foundation.org
S:	Maintained
W:	https://virtio-mem.gitlab.io/
F:	drivers/virtio/virtio_mem.c
F:	include/uapi/linux/virtio_mem.h

VIRTIO SOUND DRIVER
M:	Anton Yakovlev <anton.yakovlev@opensynergy.com>
M:	"Michael S. Tsirkin" <mst@redhat.com>
L:	virtualization@lists.linux-foundation.org
L:	alsa-devel@alsa-project.org (moderated for non-subscribers)
S:	Maintained
F:	include/uapi/linux/virtio_snd.h
F:	sound/virtio/*

VIRTIO I2C DRIVER
M:	Conghui Chen <conghui.chen@intel.com>
M:	Viresh Kumar <viresh.kumar@linaro.org>
L:	linux-i2c@vger.kernel.org
L:	virtualization@lists.linux-foundation.org
S:	Maintained
F:	drivers/i2c/busses/i2c-virtio.c
F:	include/uapi/linux/virtio_i2c.h

VIRTIO PMEM DRIVER
M:	Pankaj Gupta <pankaj.gupta.linux@gmail.com>
L:	virtualization@lists.linux-foundation.org
S:	Maintained
F:	drivers/nvdimm/virtio_pmem.c
F:	drivers/nvdimm/nd_virtio.c

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:	drivers/virt/vboxguest/
F:	include/linux/vbox_utils.h
F:	include/uapi/linux/vbox*.h

VIRTUAL BOX SHARED FOLDER VFS DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
F:	fs/vboxsf/*

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
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/test-drivers/vivid/*

VIDTV VIRTUAL DIGITAL TV DRIVER
M:	Daniel W. S. Almeida <dwlsalmeida@gmail.com>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/test-drivers/vidtv/*

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:	linux-kernel@vger.kernel.org
S:	Odd fixes
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_user/

VM SOCKETS (AF_VSOCK)
M:	Stefano Garzarella <sgarzare@redhat.com>
L:	virtualization@lists.linux-foundation.org
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/vsockmon.c
F:	include/net/af_vsock.h
F:	include/uapi/linux/vm_sockets.h
F:	include/uapi/linux/vm_sockets_diag.h
F:	include/uapi/linux/vsockmon.h
F:	net/vmw_vsock/
F:	tools/testing/vsock/

VMWARE BALLOON DRIVER
M:	Nadav Amit <namit@vmware.com>
R:	VMware PV-Drivers Reviewers <pv-drivers@vmware.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/misc/vmw_balloon.c

VMWARE HYPERVISOR INTERFACE
M:	Srivatsa S. Bhat (VMware) <srivatsa@csail.mit.edu>
M:	Alexey Makhalov <amakhalov@vmware.com>
R:	VMware PV-Drivers Reviewers <pv-drivers@vmware.com>
L:	virtualization@lists.linux-foundation.org
L:	x86@kernel.org
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86/vmware
F:	arch/x86/include/asm/vmware.h
F:	arch/x86/kernel/cpu/vmware.c

VMWARE PVRDMA DRIVER
M:	Bryan Tan <bryantan@vmware.com>
M:	Vishnu Dasa <vdasa@vmware.com>
R:	VMware PV-Drivers Reviewers <pv-drivers@vmware.com>
L:	linux-rdma@vger.kernel.org
S:	Maintained
F:	drivers/infiniband/hw/vmw_pvrdma/

VMware PVSCSI driver
M:	Vishal Bhakta <vbhakta@vmware.com>
R:	VMware PV-Drivers Reviewers <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 VIRTUAL PTP CLOCK DRIVER
M:	Vivek Thampi <vithampi@vmware.com>
R:	VMware PV-Drivers Reviewers <pv-drivers@vmware.com>
L:	netdev@vger.kernel.org
S:	Supported
F:	drivers/ptp/ptp_vmw.c

VMWARE VMCI DRIVER
M:	Bryan Tan <bryantan@vmware.com>
M:	Rajesh Jalisatgi <rjalisatgi@vmware.com>
M:	Vishnu Dasa <vdasa@vmware.com>
R:	VMware PV-Drivers Reviewers <pv-drivers@vmware.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	drivers/misc/vmw_vmci/

VMWARE VMMOUSE SUBDRIVER
M:	Zack Rusin <zackr@vmware.com>
R:	VMware Graphics Reviewers <linux-graphics-maintainer@vmware.com>
R:	VMware PV-Drivers Reviewers <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>
R:	VMware PV-Drivers Reviewers <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@vger.kernel.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
S:	Supported
W:	http://www.slimlogic.co.uk/?p=48
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator.git
F:	Documentation/devicetree/bindings/regulator/
F:	Documentation/power/regulator/
F:	drivers/regulator/
F:	include/dt-bindings/regulator/
F:	include/linux/regulator/
K:	regulator_get_optional

VOLTAGE AND CURRENT REGULATOR IRQ HELPERS
R:	Matti Vaittinen <mazziesaccount@gmail.com>
F:	drivers/regulator/irq_helpers.c

VRF
M:	David Ahern <dsahern@kernel.org>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/networking/vrf.rst
F:	drivers/net/vrf.c

VSPRINTF
M:	Petr Mladek <pmladek@suse.com>
M:	Steven Rostedt <rostedt@goodmis.org>
M:	Sergey Senozhatsky <senozhatsky@chromium.org>
R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
R:	Rasmus Villemoes <linux@rasmusvillemoes.dk>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/printk/linux.git
F:	Documentation/core-api/printk-formats.rst
F:	lib/test_printf.c
F:	lib/test_scanf.c
F:	lib/vsprintf.c

VT1211 HARDWARE MONITOR DRIVER
M:	Juerg Haefliger <juergh@gmail.com>
L:	linux-hwmon@vger.kernel.org
S:	Maintained
F:	Documentation/hwmon/vt1211.rst
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
L:	linux-mmc@vger.kernel.org
S:	Orphan
F:	drivers/mmc/host/vub300.c

W1 DALLAS'S 1-WIRE BUS
M:	Evgeniy Polyakov <zbr@ioremap.net>
S:	Maintained
F:	Documentation/devicetree/bindings/w1/
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.rst
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.rst
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

WANGXUN ETHERNET DRIVER
M:	Jiawen Wu <jiawenwu@trustnetic.com>
L:	netdev@vger.kernel.org
S:	Maintained
F:	Documentation/networking/device_drivers/ethernet/wangxun/txgbe.rst
F:	drivers/net/ethernet/wangxun/

WATCHDOG DEVICE DRIVERS
M:	Wim Van Sebroeck <wim@linux-watchdog.org>
M:	Guenter Roeck <linux@roeck-us.net>
L:	linux-watchdog@vger.kernel.org
S:	Maintained
W:	http://www.linux-watchdog.org/
T:	git git://www.linux-watchdog.org/linux-watchdog.git
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

WHWAVE RTC DRIVER
M:	Dianlong Li <long17.cool@163.com>
L:	linux-rtc@vger.kernel.org
S:	Maintained
F:	drivers/rtc/rtc-sd3078.c

WIIMOTE HID DRIVER
M:	David Rheinsberg <david.rheinsberg@gmail.com>
L:	linux-input@vger.kernel.org
S:	Maintained
F:	drivers/hid/hid-wiimote*

WILOCITY WIL6210 WIRELESS DRIVER
L:	linux-wireless@vger.kernel.org
S:	Orphan
W:	https://wireless.wiki.kernel.org/en/users/Drivers/wil6210
F:	drivers/net/wireless/ath/wil6210/

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 <william.gray@linaro.org>
L:	linux-watchdog@vger.kernel.org
S:	Maintained
F:	drivers/watchdog/ebc-c384_wdt.c

WINSYSTEMS WS16C48 GPIO DRIVER
M:	William Breathitt Gray <william.gray@linaro.org>
L:	linux-gpio@vger.kernel.org
S:	Maintained
F:	drivers/gpio/gpio-ws16c48.c

WIREGUARD SECURE NETWORK TUNNEL
M:	Jason A. Donenfeld <Jason@zx2c4.com>
L:	wireguard@lists.zx2c4.com
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/wireguard/
F:	tools/testing/selftests/wireguard/

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
S:	Supported
W:	https://github.com/CirrusLogic/linux-drivers/wiki
T:	git https://github.com/CirrusLogic/linux-drivers.git
F:	Documentation/devicetree/bindings/extcon/wlf,arizona.yaml
F:	Documentation/devicetree/bindings/mfd/wlf,arizona.yaml
F:	Documentation/devicetree/bindings/mfd/wm831x.txt
F:	Documentation/devicetree/bindings/regulator/wlf,arizona.yaml
F:	Documentation/devicetree/bindings/sound/wlf,*.yaml
F:	Documentation/devicetree/bindings/sound/wm*
F:	Documentation/hwmon/wm83??.rst
F:	arch/arm/mach-s3c/mach-crag6410*
F:	drivers/clk/clk-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/leds/leds-wm83*.c
F:	drivers/mfd/arizona*
F:	drivers/mfd/cs47l24*
F:	drivers/mfd/wm*.c
F:	drivers/power/supply/wm83*.c
F:	drivers/regulator/arizona*
F:	drivers/regulator/wm8*.c
F:	drivers/rtc/rtc-wm83*.c
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/cs47l24*
F:	sound/soc/codecs/wm*

WORKQUEUE
M:	Tejun Heo <tj@kernel.org>
R:	Lai Jiangshan <jiangshanlai@gmail.com>
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq.git
F:	Documentation/core-api/workqueue.rst
F:	include/linux/workqueue.h
F:	kernel/workqueue.c

WWAN DRIVERS
M:	Loic Poulain <loic.poulain@linaro.org>
M:	Sergey Ryazanov <ryazanov.s.a@gmail.com>
R:	Johannes Berg <johannes@sipsolutions.net>
L:	netdev@vger.kernel.org
S:	Maintained
F:	drivers/net/wwan/
F:	include/linux/wwan.h
F:	include/uapi/linux/wwan.h

X-POWERS AXP288 PMIC DRIVERS
M:	Hans de Goede <hdegoede@redhat.com>
S:	Maintained
F:	drivers/acpi/pmic/intel_pmic_xpower.c
N:	axp288

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 STACK
M:	Martin Schiller <ms@dev.tdt.de>
L:	linux-x25@vger.kernel.org
S:	Maintained
F:	Documentation/networking/lapb-module.rst
F:	Documentation/networking/x25*
F:	drivers/net/wan/hdlc_x25.c
F:	drivers/net/wan/lapbether.c
F:	include/*/lapb.h
F:	include/net/x25*
F:	include/uapi/linux/x25.h
F:	net/lapb/
F:	net/x25/

X86 ARCHITECTURE (32-BIT AND 64-BIT)
M:	Thomas Gleixner <tglx@linutronix.de>
M:	Ingo Molnar <mingo@redhat.com>
M:	Borislav Petkov <bp@alien8.de>
M:	Dave Hansen <dave.hansen@linux.intel.com>
M:	x86@kernel.org
R:	"H. Peter Anvin" <hpa@zytor.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86/core
F:	Documentation/devicetree/bindings/x86/
F:	Documentation/x86/
F:	arch/x86/

X86 ENTRY CODE
M:	Andy Lutomirski <luto@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86/asm
F:	arch/x86/entry/

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:	Documentation/ABI/testing/sysfs-mce
F:	Documentation/x86/x86_64/machinecheck.rst
F:	arch/x86/kernel/cpu/mce/*

X86 MICROCODE UPDATE SUPPORT
M:	Borislav Petkov <bp@alien8.de>
S:	Maintained
F:	arch/x86/kernel/cpu/microcode/*

X86 MM
M:	Dave Hansen <dave.hansen@linux.intel.com>
M:	Andy Lutomirski <luto@kernel.org>
M:	Peter Zijlstra <peterz@infradead.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86/mm
F:	arch/x86/mm/

X86 PLATFORM ANDROID TABLETS DSDT FIXUP DRIVER
M:	Hans de Goede <hdegoede@redhat.com>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pdx86/platform-drivers-x86.git
F:	drivers/platform/x86/x86-android-tablets.c

X86 PLATFORM DRIVERS
M:	Hans de Goede <hdegoede@redhat.com>
M:	Mark Gross <markgross@kernel.org>
L:	platform-driver-x86@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/pdx86/platform-drivers-x86.git
F:	drivers/platform/olpc/
F:	drivers/platform/x86/

X86 PLATFORM DRIVERS - ARCH
R:	Darren Hart <dvhart@infradead.org>
R:	Andy Shevchenko <andy@infradead.org>
L:	platform-driver-x86@vger.kernel.org
L:	x86@kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86/core
F:	arch/x86/platform

X86 PLATFORM UV HPE SUPERDOME FLEX
M:	Steve Wahl <steve.wahl@hpe.com>
R:	Mike Travis <mike.travis@hpe.com>
R:	Dimitri Sivanich <dimitri.sivanich@hpe.com>
R:	Russ Anderson <russ.anderson@hpe.com>
S:	Supported
F:	arch/x86/include/asm/uv/
F:	arch/x86/kernel/apic/x2apic_uv_x.c
F:	arch/x86/platform/uv/

X86 STACK UNWINDING
M:	Josh Poimboeuf <jpoimboe@kernel.org>
M:	Peter Zijlstra <peterz@infradead.org>
S:	Supported
F:	arch/x86/include/asm/unwind*.h
F:	arch/x86/kernel/dumpstack.c
F:	arch/x86/kernel/stacktrace.c
F:	arch/x86/kernel/unwind_*.c

X86 VDSO
M:	Andy Lutomirski <luto@kernel.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86/vdso
F:	arch/x86/entry/vdso/

XARRAY
M:	Matthew Wilcox <willy@infradead.org>
L:	linux-fsdevel@vger.kernel.org
S:	Supported
F:	Documentation/core-api/xarray.rst
F:	include/linux/idr.h
F:	include/linux/xarray.h
F:	lib/idr.c
F:	lib/xarray.c
F:	tools/testing/radix-tree

XBOX DVD IR REMOTE
M:	Benjamin Valentin <benpicco@googlemail.com>
S:	Maintained
F:	drivers/media/rc/keymaps/rc-xbox-dvd.c
F:	drivers/media/rc/xbox_remote.c

XC2028/3028 TUNER DRIVER
M:	Mauro Carvalho Chehab <mchehab@kernel.org>
L:	linux-media@vger.kernel.org
S:	Maintained
W:	https://linuxtv.org
T:	git git://linuxtv.org/media_tree.git
F:	drivers/media/tuners/xc2028.*

XDP (eXpress Data Path)
M:	Alexei Starovoitov <ast@kernel.org>
M:	Daniel Borkmann <daniel@iogearbox.net>
M:	David S. Miller <davem@davemloft.net>
M:	Jakub Kicinski <kuba@kernel.org>
M:	Jesper Dangaard Brouer <hawk@kernel.org>
M:	John Fastabend <john.fastabend@gmail.com>
L:	netdev@vger.kernel.org
L:	bpf@vger.kernel.org
S:	Supported
F:	include/net/xdp.h
F:	include/net/xdp_priv.h
F:	include/trace/events/xdp.h
F:	kernel/bpf/cpumap.c
F:	kernel/bpf/devmap.c
F:	net/core/xdp.c
F:	samples/bpf/xdp*
F:	tools/testing/selftests/bpf/*xdp*
F:	tools/testing/selftests/bpf/*/*xdp*
F:	drivers/net/ethernet/*/*/*/*/*xdp*
F:	drivers/net/ethernet/*/*/*xdp*
K:	(?:\b|_)xdp(?:\b|_)

XDP SOCKETS (AF_XDP)
M:	Björn Töpel <bjorn@kernel.org>
M:	Magnus Karlsson <magnus.karlsson@intel.com>
M:	Maciej Fijalkowski <maciej.fijalkowski@intel.com>
R:	Jonathan Lemon <jonathan.lemon@gmail.com>
L:	netdev@vger.kernel.org
L:	bpf@vger.kernel.org
S:	Maintained
F:	Documentation/networking/af_xdp.rst
F:	include/net/xdp_sock*
F:	include/net/xsk_buff_pool.h
F:	include/uapi/linux/if_xdp.h
F:	include/uapi/linux/xdp_diag.h
F:	include/net/netns/xdp.h
F:	net/xdp/
F:	tools/testing/selftests/bpf/*xsk*

XEN BLOCK SUBSYSTEM
M:	Roger Pau Monné <roger.pau@citrix.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
S:	Supported
F:	drivers/block/xen*
F:	drivers/block/xen-blkback/*

XEN HYPERVISOR ARM
M:	Stefano Stabellini <sstabellini@kernel.org>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
S:	Maintained
F:	arch/arm/include/asm/xen/
F:	arch/arm/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/include/asm/xen/
F:	arch/arm64/xen/

XEN HYPERVISOR INTERFACE
M:	Juergen Gross <jgross@suse.com>
M:	Stefano Stabellini <sstabellini@kernel.org>
R:	Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/xen/tip.git
F:	Documentation/ABI/stable/sysfs-hypervisor-xen
F:	Documentation/ABI/testing/sysfs-hypervisor-xen
F:	drivers/*/xen-*front.c
F:	drivers/xen/
F:	include/uapi/xen/
F:	include/xen/

XEN HYPERVISOR X86
M:	Juergen Gross <jgross@suse.com>
R:	Boris Ostrovsky <boris.ostrovsky@oracle.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
S:	Supported
F:	arch/x86/include/asm/pvclock-abi.h
F:	arch/x86/include/asm/xen/
F:	arch/x86/platform/pvh/
F:	arch/x86/xen/

XEN NETWORK BACKEND DRIVER
M:	Wei Liu <wei.liu@kernel.org>
M:	Paul Durrant <paul@xen.org>
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:	Juergen Gross <jgross@suse.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 PVUSB DRIVER
M:	Juergen Gross <jgross@suse.com>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
L:	linux-usb@vger.kernel.org
S:	Supported
F:	drivers/usb/host/xen*
F:	include/xen/interface/io/usbif.h

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

XEN SWIOTLB SUBSYSTEM
M:	Juergen Gross <jgross@suse.com>
M:	Stefano Stabellini <sstabellini@kernel.org>
L:	xen-devel@lists.xenproject.org (moderated for non-subscribers)
L:	iommu@lists.linux.dev
S:	Supported
F:	arch/x86/xen/*swiotlb*
F:	drivers/xen/*swiotlb*

XFS FILESYSTEM
C:	irc://irc.oftc.net/xfs
M:	Darrick J. Wong <djwong@kernel.org>
L:	linux-xfs@vger.kernel.org
S:	Supported
W:	http://xfs.org/
T:	git git://git.kernel.org/pub/scm/fs/xfs/xfs-linux.git
F:	Documentation/ABI/testing/sysfs-fs-xfs
F:	Documentation/admin-guide/xfs.rst
F:	Documentation/filesystems/xfs-delayed-logging-design.rst
F:	Documentation/filesystems/xfs-self-describing-metadata.rst
F:	fs/xfs/
F:	include/uapi/linux/dqblk_xfs.h
F:	include/uapi/linux/fsmap.h

XILINX AMS DRIVER
M:	Anand Ashok Dumbre <anand.ashok.dumbre@xilinx.com>
L:	linux-iio@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/iio/adc/xlnx,zynqmp-ams.yaml
F:	drivers/iio/adc/xilinx-ams.c

XILINX AXI ETHERNET DRIVER
M:	Radhey Shyam Pandey <radhey.shyam.pandey@xilinx.com>
S:	Maintained
F:	drivers/net/ethernet/xilinx/xilinx_axienet*

XILINX CAN DRIVER
M:	Appana Durga Kedareswara rao <appana.durga.rao@xilinx.com>
R:	Naga Sureshkumar Relli <naga.sureshkumar.relli@xilinx.com>
L:	linux-can@vger.kernel.org
S:	Maintained
F:	Documentation/devicetree/bindings/net/can/xilinx,can.yaml
F:	drivers/net/can/xilinx_can.c

XILINX GPIO DRIVER
M:	Shubhrajyoti Datta <shubhrajyoti.datta@xilinx.com>
R:	Srinivas Neeli <srinivas.neeli@xilinx.com>
R:	Michal Simek <michal.simek@xilinx.com>
S:	Maintained
F:	Documentation/devicetree/bindings/gpio/gpio-xilinx.txt
F:	Documentation/devicetree/bindings/gpio/gpio-zynq.yaml
F:	drivers/gpio/gpio-xilinx.c
F:	drivers/gpio/gpio-zynq.c

XILINX SD-FEC IP CORES
M:	Derek Kiernan <derek.kiernan@xilinx.com>
M:	Dragan Cvetic <dragan.cvetic@xilinx.com>
S:	Maintained
F:	Documentation/devicetree/bindings/misc/xlnx,sd-fec.txt
F:	Documentation/misc-devices/xilinx_sdfec.rst
F:	drivers/misc/Kconfig
F:	drivers/misc/Makefile
F:	drivers/misc/xilinx_sdfec.c
F:	include/uapi/misc/xilinx_sdfec.h

XILINX PWM DRIVER
M:	Sean Anderson <sean.anderson@seco.com>
S:	Maintained
F:	drivers/pwm/pwm-xilinx.c
F:	include/clocksource/timer-xilinx.h

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
S:	Supported
T:	git git://linuxtv.org/media_tree.git
F:	Documentation/devicetree/bindings/media/xilinx/
F:	drivers/media/platform/xilinx/
F:	include/uapi/linux/xilinx-v4l2-controls.h

XILINX ZYNQMP DPDMA DRIVER
M:	Hyun Kwon <hyun.kwon@xilinx.com>
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	dmaengine@vger.kernel.org
S:	Supported
F:	Documentation/devicetree/bindings/dma/xilinx/xlnx,zynqmp-dpdma.yaml
F:	drivers/dma/xilinx/xilinx_dpdma.c
F:	include/dt-bindings/dma/xlnx-zynqmp-dpdma.h

XILINX ZYNQMP PSGTR PHY DRIVER
M:	Anurag Kumar Vulisha <anurag.kumar.vulisha@xilinx.com>
M:	Laurent Pinchart <laurent.pinchart@ideasonboard.com>
L:	linux-kernel@vger.kernel.org
S:	Supported
T:	git https://github.com/Xilinx/linux-xlnx.git
F:	Documentation/devicetree/bindings/phy/xlnx,zynqmp-psgtr.yaml
F:	drivers/phy/xilinx/phy-zynqmp.c

XILINX ZYNQMP SHA3 DRIVER
M:	Harsha <harsha.harsha@xilinx.com>
S:	Maintained
F:	drivers/crypto/xilinx/zynqmp-sha.c

XILINX EVENT MANAGEMENT DRIVER
M:	Abhyuday Godhasara <abhyuday.godhasara@xilinx.com>
S:	Maintained
F:	drivers/soc/xilinx/xlnx_event_manager.c
F:	include/linux/firmware/xlnx-event-manager.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 <gcherian@marvell.com>
L:	linux-i2c@vger.kernel.org
S:	Supported
W:	http://www.marvell.com
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:	Documentation/devicetree/bindings/gpio/gpio-xra1403.txt
F:	drivers/gpio/gpio-xra1403.c

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>
S:	Supported
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/kees/linux.git for-next/hardening
F:	Documentation/admin-guide/LSM/Yama.rst
F:	security/yama/

YEALINK PHONE DRIVER
M:	Henk Vergonet <Henk.Vergonet@gmail.com>
L:	usbb2k-api-dev@nongnu.org
S:	Maintained
F:	Documentation/input/devices/yealink.rst
F:	drivers/input/misc/yealink.*

Z8530 DRIVER FOR AX.25
M:	Joerg Reuter <jreuter@yaina.de>
L:	linux-hams@vger.kernel.org
S:	Maintained
W:	http://yaina.de/jreuter/
W:	http://www.qsl.net/dl1bke/
F:	Documentation/networking/device_drivers/hamradio/z8530drv.rst
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

Z3FOLD COMPRESSED PAGE ALLOCATOR
M:	Vitaly Wool <vitaly.wool@konsulko.com>
R:	Miaohe Lin <linmiaohe@huawei.com>
L:	linux-mm@kvack.org
S:	Maintained
F:	mm/z3fold.c

ZD1211RW WIRELESS DRIVER
M:	Ulrich Kunitz <kune@deine-taler.de>
L:	linux-wireless@vger.kernel.org
L:	zd1211-devs@lists.sourceforge.net (subscribers-only)
S:	Maintained
W:	http://zd1211.ath.cx/wiki/DriverRewrite
F:	drivers/net/wireless/zydas/zd1211rw/

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

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

ZHAOXIN PROCESSOR SUPPORT
M:	Tony W Wang-oc <TonyWWang-oc@zhaoxin.com>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	arch/x86/kernel/cpu/zhaoxin.c

ZONEFS FILESYSTEM
M:	Damien Le Moal <damien.lemoal@opensource.wdc.com>
M:	Naohiro Aota <naohiro.aota@wdc.com>
R:	Johannes Thumshirn <jth@kernel.org>
L:	linux-fsdevel@vger.kernel.org
S:	Maintained
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/dlemoal/zonefs.git
F:	Documentation/filesystems/zonefs.rst
F:	fs/zonefs/

ZPOOL COMPRESSED PAGE STORAGE API
M:	Dan Streetman <ddstreet@ieee.org>
L:	linux-mm@kvack.org
S:	Maintained
F:	include/linux/zpool.h
F:	mm/zpool.c

ZR36067 VIDEO FOR LINUX DRIVER
M:	Corentin Labbe <clabbe@baylibre.com>
L:	mjpeg-users@lists.sourceforge.net
L:	linux-media@vger.kernel.org
S:	Maintained
W:	http://mjpeg.sourceforge.net/driver-zoran/
Q:	https://patchwork.linuxtv.org/project/linux-media/list/
F:	Documentation/driver-api/media/drivers/zoran.rst
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 <senozhatsky@chromium.org>
L:	linux-kernel@vger.kernel.org
S:	Maintained
F:	Documentation/admin-guide/blockdev/zram.rst
F:	drivers/block/zram/

ZS DECSTATION Z85C30 SERIAL DRIVER
M:	"Maciej W. Rozycki" <macro@orcam.me.uk>
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 <senozhatsky@chromium.org>
L:	linux-mm@kvack.org
S:	Maintained
F:	Documentation/vm/zsmalloc.rst
F:	include/linux/zsmalloc.h
F:	mm/zsmalloc.c

ZSTD
M:	Nick Terrell <terrelln@fb.com>
S:	Maintained
B:	https://github.com/facebook/zstd/issues
T:	git git://github.com/terrelln/linux.git
F:	include/linux/zstd*
F:	lib/zstd/
F:	lib/decompress_unzstd.c
F:	crypto/zstd.c
N:	zstd
K:	zstd

ZSWAP COMPRESSED SWAP CACHING
M:	Seth Jennings <sjenning@redhat.com>
M:	Dan Streetman <ddstreet@ieee.org>
M:	Vitaly Wool <vitaly.wool@konsulko.com>
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
S:	Buried alive in reporters
T:	git git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
F:	*
F:	*/
