bybrooklyn/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-04-18 06:44:00 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge tag 'media/v7.1-1' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

Browse Source 
Pull media updates from Mauro Carvalho Chehab:

 - new CSI tegra support, covering Tegra20 and Tegra30

 - new camera sensor drivers: T4ka3 and ov2732

 - m88ds3103: add 3103c chip support

 - uvcvideo: add support for Intel RealSense D436/D555 and P010 pixel format

 - synopsys csi2rx: add i.MX93 support

 - imx8-isi: add i.MX95 support

 - imx8mq-mipi-csi2: add i.MX8ULP support

 - dw100: add V4L2 requests support

 - support for DTV devices from Hauppauge got some improvements

 - media staging: dropped starfive-camss driver

 - media docs: document multi-committers model and improve maint profile

 - media core:
    - add v4l2_subdev_get_frame_desc_passthrough() helper
    - improve error handling in fwnode parsing

 - lots of driver fixes, cleanups and improvements

* tag 'media/v7.1-1' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (251 commits)
  Revert "media: cx231xx: add USB ID 2040:8360 for Hauppauge WinTV-HVR-935"
  media: synopsys: csi2rx: add i.MX93 support
  media: dt-bindings: add NXP i.MX93 compatible string
  media: synopsys: csi2rx: Use enum and u32 array for register offsets
  media: synopsys: csi2rx: implement .get_frame_desc() callback
  media: synopsys: csi2rx: only check errors from devm_clk_bulk_get_all()
  media: synopsys: csi2rx: use devm_reset_control_get_optional_exclusive()
  media: i2c: imx283: add support for non-continuous MIPI clock mode
  media: i2c: ov08d10: add support for 24 MHz input clock
  media: i2c: ov08d10: add support for reset and power management
  media: i2c: ov08d10: add support for binding via device tree
  dt-bindings: media: i2c: document Omnivision OV08D10 CMOS image sensor
  media: i2c: ov08d10: add missing newline to prints
  media: i2c: ov08d10: fix some typos in comments
  media: i2c: ov08d10: remove duplicate register write
  media: i2c: ov08d10: fix image vertical start setting
  media: i2c: ov08d10: fix runtime PM handling in probe
  staging: media: ipu7: Update TODO
  media: Add t4ka3 camera sensor driver
  media: i2c: Add ov2732 image sensor driver
  ...
This commit is contained in:
Linus Torvalds
2026-04-15 08:32:10 -07:00
parent 1f5ffc6721 4fbeef21f5
commit 00c6649baf
266 changed files with 10060 additions and 7144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Documentation/driver-api/media/index.rst
View File

@@ -26,6 +26,7 @@ Documentation/userspace-api/media/index.rst
:numbered:
maintainer-entry-profile
media-committers
v4l2-core
dtv-core

463
Documentation/driver-api/media/maintainer-entry-profile.rst
View File

@@ -1,45 +1,328 @@
.. SPDX-License-Identifier: GPL-2.0
Media Subsystem Profile
=======================
Overview
--------
The media subsystem covers support for a variety of devices: stream
capture, analog and digital TV streams, cameras, remote controllers, HDMI CEC
and media pipeline control.
The Linux Media Community (aka: the LinuxTV Community) is formed by
developers working on Linux Kernel Media Subsystem, together with users
who also play an important role in testing the code.
It covers, mainly, the contents of those directories:
The Media Subsystem has code to support a wide variety of media-related
devices: stream capture, analog and digital TV streams, cameras,
video codecs, video processing (resizers, etc.), radio, remote controllers,
HDMI CEC and media pipeline control.
The Media Subsystem consists of the following directories in the kernel
tree:
- drivers/media
- drivers/staging/media
- include/media
- Documentation/devicetree/bindings/media/\ [1]_
- Documentation/admin-guide/media
- Documentation/driver-api/media
- Documentation/userspace-api/media
- Documentation/devicetree/bindings/media/\ [1]_
- include/media
.. [1] Device tree bindings are maintained by the
OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS maintainers
(see the MAINTAINERS file). So, changes there must be reviewed
by them before being merged via the media subsystem's development
by them before being merged into the media subsystem's development
tree.
Both media userspace and Kernel APIs are documented and the documentation
must be kept in sync with the API changes. It means that all patches that
add new features to the subsystem must also bring changes to the
corresponding API files.
corresponding API documentation.
Due to the size and wide scope of the media subsystem, media's
maintainership model is to have sub-maintainers that have a broad
knowledge of a specific aspect of the subsystem. It is the sub-maintainers'
task to review the patches, providing feedback to users if the patches are
following the subsystem rules and are properly using the media kernel and
userspace APIs.
Media Maintainers
-----------------
Patches for the media subsystem must be sent to the media mailing list
at linux-media@vger.kernel.org as plain text only e-mail. Emails with
HTML will be automatically rejected by the mail server. It could be wise
to also copy the sub-maintainer(s).
Media Maintainers are not just people capable of writing code, but they
are developers who have demonstrated their ability to collaborate with
the team, get the most knowledgeable people to review code, contribute
high-quality code, and follow through to fix issues (in code or tests).
Due to the size and wide scope of the media subsystem, multiple layers of
maintainers are required, each with their own areas of expertise:
- **Media Driver Maintainer**:
Responsible for one or more drivers within the Media Subsystem. They
are listed in the MAINTAINERS file as maintainer for those drivers. Media
Driver Maintainers review patches for those drivers, provide feedback if
patches do not follow the subsystem rules, or are not using the
media kernel or userspace APIs correctly, or if they have poor code
quality.
If you are the patch author, you work with other Media
Maintainers to ensure your patches are reviewed.
Some Media Driver Maintainers have additional responsibilities. They have
been granted Patchwork access and keep
`Patchwork <https://patchwork.linuxtv.org/project/linux-media/list/>`_
up to date, decide when patches are ready for merging, and create Pull
Requests for the Media Subsystem Maintainers to merge.
- **Media Core Maintainer**:
Media Driver Maintainers with Patchwork access who are also responsible for
one or more media core frameworks.
Core framework changes are done via consensus between the relevant Media
Core Maintainers. Media Maintainers may include core framework changes in
their Pull Requests if they are signed off by the relevant Media Core
Maintainers.
- **Media Subsystem Maintainers**:
Media Core Maintainers who are also responsible for the subsystem as a
whole, with access to the entire subsystem. Responsible for merging Pull
Requests from other Media Maintainers.
Userspace API/ABI changes are made via consensus among Media Subsystem
Maintainers\ [2]_. Media Maintainers may include API/ABI changes in
their Pull Requests if they are signed off by all Media Subsystem
Maintainers.
All Media Maintainers shall agree with the Kernel development process as
described in Documentation/process/index.rst and with the Kernel development
rules in the Kernel documentation, including its code of conduct.
Media Maintainers are often reachable via the #linux-media IRC channel at OFTC.
.. [2] Everything that would break backward compatibility with existing
non-kernel code are API/ABI changes. This includes ioctl and sysfs
interfaces, v4l2 controls, and their behaviors.
Patchwork Access
----------------
All Media Maintainers who have been granted Patchwork access shall ensure that
`Patchwork <https://patchwork.linuxtv.org/project/linux-media/list/>`_
will reflect the current status, e.g. patches shall be delegated to the Media
Maintainer who is handling them and the patch status shall be updated according
to these rules:
- ``Under Review``: Used if the patch requires a second opinion
or when it is part of a Pull Request;
- ``Superseded``: There is a newer version of the patch posted to the
mailing list.
- ``Duplicated``: There was another patch doing the same thing from someone
else that was accepted.
- ``Not Applicable``: Use for patch series that are not merged at media.git
tree (e.g. drm, dmabuf, upstream merge, etc.) but were cross-posted to the
linux-media mailing list.
- ``Accepted``: Once a patch is merged in the multi-committer tree. Only Media
Maintainers with commit rights are allowed to set this state.
If Media Maintainers decide not to accept a patch, they should reply to the
patch authors by e‑mail, explaining why it is not accepted, and
update `Patchwork <https://patchwork.linuxtv.org/project/linux-media/list/>`_
accordingly with one of the following statuses:
- ``Changes Requested``: if a new revision was requested;
- ``Rejected``: if the proposed change is not acceptable at all.
.. Note::
Patchwork supports a couple of clients to help semi-automate
status updates via its REST interface:
https://patchwork.readthedocs.io/en/latest/usage/clients/
For patches that fall within their area of responsibility a Media Maintainer
also decides when those patches are ready for merging, and create Pull Requests
for the Media Subsystem Maintainers to merge.
The most important aspect of becoming a Media Maintainer with Patchwork access
is that you have demonstrated an ability to give good code reviews. We value
your ability to deliver thorough, constructive code reviews.
As such, potential maintainers must earn enough credibility and trust from the
Linux Media Community. To do that, developers shall be familiar with the open
source model and have been active in the Linux Kernel community for some time,
and, in particular, in the media subsystem.
In addition to actually making the code changes, you are basically
demonstrating your:
- commitment to the project;
- ability to collaborate with the team and communicate well;
- understanding of how upstream and the Linux Media Community work
(policies, processes for testing, code review, ...)
- reasonable knowledge about:
- the Kernel development process:
Documentation/process/index.rst
- the Media development profile:
Documentation/driver-api/media/maintainer-entry-profile.rst
- understanding of the projects' code base and coding style;
- ability to provide feedback to the patch authors;
- ability to judge when a patch might be ready for review and to submit;
- ability to write good code (last but certainly not least).
Media Driver Maintainers that desire to get Patchwork access are encouraged
to participate at the yearly Linux Media Summit, typically co-located with
a Linux-related conference. These summits are announced on the linux-media
mailing list.
If you are doing such tasks and have become a valued developer, an
existing Media Maintainer can nominate you to the Media Subsystem Maintainers.
The ultimate responsibility for accepting a nominated maintainer is up to
the subsystem's maintainers. The nominated maintainer must have earned a trust
relationship with all Media Subsystem Maintainers, as, by being granted
Patchwork access, you will take over part of their maintenance tasks.
Media Committers
----------------
Experienced and trusted Media Maintainers may be granted commit rights
which allow them to directly push patches to the media development tree instead
of posting a Pull Request for the Media Subsystem Maintainers. This helps
offloading some of the work of the Media Subsystem Maintainers.
More details about Media Committers' roles and responsibilities can be
found here: :ref:`Media Committers`.
Media development sites
-----------------------
The `LinuxTV <https://linuxtv.org/>`_ web site hosts news about the subsystem,
together with:
- `Wiki pages <https://www.linuxtv.org/wiki/index.php/Main_Page>`_;
- `Patchwork <https://patchwork.linuxtv.org/project/linux-media/list/>`_;
- `Linux Media documentation <https://linuxtv.org/docs.php>`_;
- and more.
The main development trees used by the media subsystem are at:
- Stable tree:
- https://git.linuxtv.org/media.git/
- Media committers tree:
- https://gitlab.freedesktop.org/linux-media/media-committers.git
Please note that it can be rebased, although only as a last resort.
- Media development trees, including apps and CI:
- https://git.linuxtv.org/
- https://gitlab.freedesktop.org/linux-media/
.. _Media development workflow:
Media development workflow
++++++++++++++++++++++++++
All changes for the media subsystem shall be sent first as e-mails to the
media mailing list, following the process documented at
Documentation/process/index.rst.
It means that patches shall be submitted as plain text only via e-mail to
linux-media@vger.kernel.org (aka: LMML). While subscription is not mandatory,
you can find details about how to subscribe to it and to see its archives at:
https://subspace.kernel.org/vger.kernel.org.html
Emails with HTML will be automatically rejected by the mail server.
It could be wise to also copy the relevant Media Maintainer(s). You should use
``scripts/get_maintainers.pl`` to identify whom else needs to be copied.
Please always copy driver's authors and maintainers.
To minimize the chance of merge conflicts for your patch series, and make it
easier to backport patches to stable Kernels, we recommend that you use the
following baseline for your patch series:
1. Features for the next mainline release:
- baseline shall be the ``media-committers.git next`` branch;
2. Bug fixes for the next mainline release:
- baseline shall be the ``media-committers.git next`` branch. If the
changes depend on a fix from the ``media-committers.git fixes``
branch, then you can use that as baseline.
3. Bug fixes for the current mainline release (-rcX):
- baseline shall be the latest mainline -rcX release or the
``media-committers.git fixes`` branch if changes depend on a mainline
fix that is not yet merged;
.. Note::
See https://www.kernel.org/category/releases.html for an overview
about Kernel release types.
Patches with fixes shall have:
- a ``Fixes:`` tag pointing to the first commit that introduced the bug;
- when applicable, a ``Cc: stable@vger.kernel.org``.
Patches that were fixing bugs publicly reported by someone at the
linux-media@vger.kernel.org mailing list shall have:
- a ``Reported-by:`` tag immediately followed by a ``Closes:`` tag.
Patches that change API shall update documentation accordingly at the
same patch series.
See Documentation/process/index.rst for more details about e-mail submission.
Once a patch is submitted, it may follow either one of the following
workflows:
a. Media Maintainers' workflow: Media Maintainers post the Pull Requests,
which are handled by the Media Subsystem Maintainers::
+-------+ +------------+ +------+ +-------+ +---------------------+
|e-mail |-->|picked up by|-->|code |-->|pull |-->|Subsystem Maintainers|
|to LMML| |Patchwork | |review| |request| |merge in |
| | | | | | | | |media-committers.git |
+-------+ +------------+ +------+ +-------+ +---------------------+
For this workflow, Pull Requests are generated by Media Maintainers with
Patchwork access. If you do not have Patchwork access, then please don't
submit Pull Requests, as they will not be processed.
b. Media Committers' workflow: patches are handled by Media Maintainers with
commit rights::
+-------+ +------------+ +------+ +--------------------------+
|e-mail |-->|picked up by|-->|code |-->|Media Committers merge in |
|to LMML| |Patchwork | |review| |media-committers.git |
+-------+ +------------+ +------+ +--------------------------+
When patches are picked up by
`Patchwork <https://patchwork.linuxtv.org/project/linux-media/list/>`_
and when merged at media-committers, Media CI bots will check for errors and
may provide e-mail feedback about patch problems. When this happens, the patch
submitter must fix them or explain why the errors are false positives.
Patches will only be moved to the next stage in these two workflows if they
pass on Media CI or if there are false-positives in the Media CI reports.
For both workflows, all patches shall be properly reviewed at
linux-media@vger.kernel.org (LMML) before being merged in
``media-committers.git``. Media patches will be reviewed in a timely manner
by the maintainers and reviewers as listed in the MAINTAINERS file.
Media Maintainers shall request reviews from other Media Maintainers and
developers where applicable, i.e. because those developers have more
knowledge about some areas that are changed by a patch.
There shall be no open issues or unresolved or conflicting feedback
from anyone. Clear them up first. Defer to the Media Subsystem
Maintainers if needed.
Failures during e-mail submission
+++++++++++++++++++++++++++++++++
Media's workflow is heavily based on Patchwork, meaning that, once a patch
is submitted, the e-mail will first be accepted by the mailing list
@@ -47,51 +330,107 @@ server, and, after a while, it should appear at:
- https://patchwork.linuxtv.org/project/linux-media/list/
If it doesn't automatically appear there after a few minutes, then
If it doesn't automatically appear there after some time [3]_, then
probably something went wrong on your submission. Please check if the
email is in plain text\ [2]_ only and if your emailer is not mangling
email is in plain text\ [4]_ only and if your emailer is not mangling
whitespaces before complaining or submitting them again.
You can check if the mailing list server accepted your patch, by looking at:
To troubleshoot problems, you should first check if the mailing list
server has accepted your patch, by looking at:
- https://lore.kernel.org/linux-media/
.. [2] If your email contains HTML, the mailing list server will simply
If the patch is there and not at
`Patchwork <https://patchwork.linuxtv.org/project/linux-media/list/>`_,
it is likely that your e-mailer mangled the patch. Patchwork internally
has logic that checks if the received e-mail contains a valid patch.
Any whitespace and new line breakages mangling the patch won't be recognized by
`Patchwork <https://patchwork.linuxtv.org/project/linux-media/list/>`_,
and such a patch will be rejected.
.. [3] It usually takes a few minutes for the patch to arrive, but
the e-mail server may be busy, so it may take a longer time
for a patch to be picked by
`Patchwork <https://patchwork.linuxtv.org/project/linux-media/list/>`_.
.. [4] If your email contains HTML, the mailing list server will simply
drop it, without any further notice.
.. _media-developers-gpg:
Media maintainers
+++++++++++++++++
Authentication for pull and merge requests
++++++++++++++++++++++++++++++++++++++++++
At the media subsystem, we have a group of senior developers that
are responsible for doing the code reviews at the drivers (also known as
sub-maintainers), and another senior developer responsible for the
subsystem as a whole. For core changes, whenever possible, multiple
media maintainers do the review.
The authenticity of developers submitting Pull Requests and merge requests
shall be validated by using the Linux Kernel Web of Trust, with PGP signing
at some moment. See: :ref:`kernel_org_trust_repository`.
The media maintainers that work on specific areas of the subsystem are:
With the Pull Request workflow, Pull Requests shall use PGP-signed tags.
- Remote Controllers (infrared):
Sean Young <sean@mess.org>
With the committers' workflow, this is ensured at the time merge request
rights will be granted to the gitlab instance used by the media-committers.git
tree, after receiving the e-mail documented in
:ref:`media-committer-agreement`.
- HDMI CEC:
Hans Verkuil <hverkuil@kernel.org>
For more details about PGP signing, please read
Documentation/process/maintainer-pgp-guide.rst.
- Media controller drivers:
Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Maintaining media maintainer status
-----------------------------------
- ISP, v4l2-async, v4l2-fwnode, v4l2-flash-led-class and Sensor drivers:
Sakari Ailus <sakari.ailus@linux.intel.com>
See :ref:`Maintain Media Status`.
- V4L2 drivers and core V4L2 frameworks:
Hans Verkuil <hverkuil@kernel.org>
List of Media Maintainers
-------------------------
The subsystem maintainer is:
Mauro Carvalho Chehab <mchehab@kernel.org>
The Media Maintainers listed here all have patchwork access and can
make Pull Requests or have commit rights.
Media maintainers may delegate a patch to other media maintainers as needed.
On such case, checkpatch's ``delegate`` field indicates who's currently
responsible for reviewing a patch.
The Media Subsystem Maintainers are:
- Mauro Carvalho Chehab <mchehab@kernel.org>
- Hans Verkuil <hverkuil@kernel.org>
The Media Core Maintainers are:
- Sakari Ailus <sakari.ailus@linux.intel.com>
- Media controller drivers
- Core media controller framework
- ISP
- sensor drivers
- v4l2-async and v4l2-fwnode core frameworks
- v4l2-flash-led-class core framework
- Mauro Carvalho Chehab <mchehab@kernel.org>
- DVB
- Laurent Pinchart <laurent.pinchart@ideasonboard.com>
- Media controller drivers
- Core media controller framework
- ISP
- Hans Verkuil <hverkuil@kernel.org>
- V4L2 drivers
- V4L2 and videobuf2 core frameworks
- HDMI CEC drivers
- HDMI CEC core framework
- Sean Young <sean@mess.org>
- Remote Controller (infrared) drivers
- Remote Controller (infrared) core framework
The Media Driver Maintainers responsible for specific areas are:
- Nicolas Dufresne <nicolas.dufresne@collabora.com>
- Codec drivers
- M2M driver not otherwise delegated
- Bryan O'Donoghue <bryan.odonoghue@linaro.org>
- Qualcomm drivers
Submit Checklist Addendum
-------------------------
@@ -106,18 +445,15 @@ that should be used in order to check if the drivers are properly
implementing the media APIs:
==================== =======================================================
Type Tool
Type Utility
==================== =======================================================
V4L2 drivers\ [3]_ ``v4l2-compliance``
V4L2 drivers\ [5]_ ``v4l2-compliance``
V4L2 virtual drivers ``contrib/test/test-media``
CEC drivers ``cec-compliance``
==================== =======================================================
.. [3] The ``v4l2-compliance`` also covers the media controller usage inside
V4L2 drivers.
Other compliance tools are under development to check other parts of the
subsystem.
.. [5] The ``v4l2-compliance`` utility also covers the media controller usage
inside V4L2 drivers.
Those tests need to pass before the patches go upstream.
@@ -134,6 +470,8 @@ Where the check script is::
Be sure to not introduce new warnings on your patches without a
very good reason.
Please see `Media development workflow`_ for e-mail submission rules.
Style Cleanup Patches
+++++++++++++++++++++
@@ -173,34 +511,35 @@ least, simply wrapping the lines.
In particular, we accept lines with more than 80 columns:
- on strings, as they shouldn't be broken due to line length limits;
- when a function or variable name need to have a big identifier name,
which keeps hard to honor the 80 columns limit;
- when a function or variable name needs to have a long identifier name,
which makes hard to honor the 80 columns limit;
- on arithmetic expressions, when breaking lines makes them harder to
read;
- when they avoid a line to end with an open parenthesis or an open
- when they avoid a line ending with an open parenthesis or an open
bracket.
Key Cycle Dates
---------------
New submissions can be sent at any time, but if they intend to hit the
New submissions can be sent at any time, but if they are intended to hit the
next merge window they should be sent before -rc5, and ideally stabilized
in the linux-media branch by -rc6.
Review Cadence
--------------
Provided that your patch is at https://patchwork.linuxtv.org, it should
be sooner or later handled, so you don't need to re-submit a patch.
Provided that your patch has landed in
`Patchwork <https://patchwork.linuxtv.org/project/linux-media/list/>`_, it
should be sooner or later handled, so you don't need to re-submit a patch.
Except for bug fixes, we don't usually add new patches to the development
tree between -rc6 and the next -rc1.
Except for important bug fixes, we don't usually add new patches to the
development tree between -rc6 and the next -rc1.
Please notice that the media subsystem is a high traffic one, so it
could take a while for us to be able to review your patches. Feel free
to ping if you don't get a feedback in a couple of weeks or to ask
other developers to publicly add Reviewed-by and, more importantly,
other developers to publicly add ``Reviewed-by:`` and, more importantly,
``Tested-by:`` tags.
Please note that we expect a detailed description for ``Tested-by:``,
identifying what boards were used at the test and what it was tested.
identifying what boards were used during the test and what it was tested.

203
Documentation/driver-api/media/media-committers.rst Normal file
View File

@@ -0,0 +1,203 @@
.. SPDX-License-Identifier: GPL-2.0
.. _Media Committers:
Media Committers
================
Who is a Media Committer?
-------------------------
A Media Committer is a Media Maintainer with patchwork access who has been
granted commit access to push patches from other developers and their own
patches to the
`media-committers <https://gitlab.freedesktop.org/linux-media/media-committers>`_
tree.
These commit rights are granted with expectation of responsibility:
committers are people who care about the Linux Kernel as a whole and
about the Linux media subsystem and want to advance its development. It
is also based on a trust relationship among other committers, maintainers
and the Linux Media community.
As Media Committer you have the following additional responsibilities:
1. Patches you authored must have a ``Signed-off-by``, ``Reviewed-by``
or ``Acked-by`` from another Media Maintainer;
2. If a patch introduces a regression, then that must be corrected as soon
as possible. Typically the patch is either reverted, or an additional
patch is committed to fix the regression;
3. If patches are fixing bugs against already released Kernels, including
the reverts mentioned above, the Media Committer shall add the needed
tags. Please see :ref:`Media development workflow` for more details.
4. All Media Committers are responsible for maintaining
`Patchwork <https://patchwork.linuxtv.org/project/linux-media/list/>`_,
updating the state of the patches they review or merge.
Becoming a Media Committer
--------------------------
Existing Media Committers can nominate a Media Maintainer to be granted
commit rights. The Media Maintainer must have patchwork access,
have been reviewing patches from third parties for some time, and has
demonstrated a good understanding of the maintainer's duties and processes.
The ultimate responsibility for accepting a nominated committer is up to
the Media Subsystem Maintainers. The nominated committer must have earned a
trust relationship with all Media Subsystem Maintainers, as, by granting you
commit rights, part of their responsibilities are handed over to you.
Due to that, to become a Media Committer, a consensus between all Media
Subsystem Maintainers is required.
.. Note::
In order to preserve/protect the developers that could have their commit
rights granted, denied or removed as well as the subsystem maintainers who
have the task to accept or deny commit rights, all communication related to
changing commit rights should happen in private as much as possible.
.. _media-committer-agreement:
Media Committer's agreement
---------------------------
Once a nominated committer is accepted by all Media Subsystem Maintainers,
they will ask if the developer is interested in the nomination and discuss
what area(s) of the media subsystem the committer will be responsible for.
Those areas will typically be the same as the areas that the nominated
committer is already maintaining.
When the developer accepts being a committer, the new committer shall
explicitly accept the Kernel development policies described under its
Documentation/, and in particular to the rules in this document, by writing
an e-mail to media-committers@linuxtv.org, with a declaration of intent
following the model below::
I, John Doe, would like to change my status to: Committer
As Media Maintainer I accept commit rights for the following areas of
the media subsystem:
...
For the purpose of committing patches to the media-committers tree,
I'll be using my user https://gitlab.freedesktop.org/users/<username>.
Followed by a formal declaration of agreement with the Kernel development
rules::
I agree to follow the Kernel development rules described at:
https://www.kernel.org/doc/html/latest/driver-api/media/media-committers.rst
and to the Linux Kernel development process rules.
I agree to abide by the Code of Conduct as documented in:
https://www.kernel.org/doc/html/latest/process/code-of-conduct.rst
I am aware that I can, at any point of time, retire. In that case, I will
send an e-mail to notify the Media Subsystem Maintainers for them to revoke
my commit rights.
I am aware that the Kernel development rules change over time.
By doing a new push to media-committers tree, I understand that I agree
to follow the rules in effect at the time of the commit.
That e-mail shall be signed via the Kernel Web of trust with a PGP key cross
signed by other Kernel and media developers. As described at
:ref:`media-developers-gpg`, the PGP signature, together with the gitlab user
security are fundamental components that ensure the authenticity of the merge
requests that will happen at the media-committers.git tree.
In case the kernel development process changes, by merging new commits to the
`media-committers tree <https://gitlab.freedesktop.org/linux-media/media-committers>`_,
the Media Committer implicitly declares their agreement with the latest
version of the documented process including the contents of this file.
If a Media Committer decides to retire, it is the committer's duty to
notify the Media Subsystem Maintainers about that decision.
.. note::
1. Changes to the kernel media development process shall be announced in
the media-committers mailing list with a reasonable review period. All
committers are automatically subscribed to that mailing list;
2. Due to the distributed nature of the Kernel development, it is
possible that kernel development process changes may end being
reviewed/merged at the Linux Docs and/or at the Linux Kernel mailing
lists, especially for the contents under Documentation/process and for
trivial typo fixes.
Media Core Committers
---------------------
A Media Core Committer is a Media Core Maintainer with commit rights.
As described in Documentation/driver-api/media/maintainer-entry-profile.rst,
a Media Core Maintainer maintains media core frameworks as well, besides
just drivers, and so is allowed to change core files and the media subsystem's
Kernel API. The extent of the core committer's grants will be detailed by the
Media Subsystem Maintainers when they nominate a Media Core Committer.
Existing Media Committers may become Media Core Committers and vice versa.
Such decisions will be taken in consensus among the Media Subsystem
Maintainers.
Media committers rules
----------------------
Media committers shall do their best efforts to avoid merging patches that
would break any existing drivers. If it breaks, fixup or revert patches
shall be merged as soon as possible, aiming to be merged at the same Kernel
cycle the bug is reported.
Media committers shall behave accordingly to the rights granted by
the Media Subsystem Maintainers, especially with regards of the scope of changes
they may apply directly at the media-committers tree. That scope can
change over time on a mutual agreement between Media Committers and
Media Subsystem Maintainers.
The Media Committer workflow is described at :ref:`Media development workflow`.
.. _Maintain Media Status:
Maintaining Media Maintainer or Committer status
------------------------------------------------
A community of maintainers working together to move the Linux Kernel
forward is essential to creating successful projects that are rewarding
to work on. If there are problems or disagreements within the community,
they can usually be solved through healthy discussion and debate.
In the unhappy event that a Media Maintainer or Committer continues to
disregard good citizenship (or actively disrupts the project), we may need
to revoke that person's status. In such cases, if someone suggests the
revocation with a good reason, then after discussing this among the Media
Maintainers, the final decision is taken by the Media Subsystem Maintainers.
As the decision to become a Media Maintainer or Committer comes from a
consensus between Media Subsystem Maintainers, a single Media Subsystem
Maintainer not trusting the Media Maintainer or Committer anymore is enough
to revoke their maintenance, Patchwork grants and/or commit rights.
Having commit rights revoked doesn't prevent Media Maintainers to keep
contributing to the subsystem either via the pull request or via email workflow
as documented at the :ref:`Media development workflow`.
If a maintainer is inactive for more than a couple of Kernel cycles,
maintainers will try to reach you via e-mail. If not possible, they may
revoke their maintainer/patchwork and committer rights and update MAINTAINERS
file entries accordingly. If you wish to resume contributing as maintainer
later on, then contact the Media Subsystem Maintainers to ask if your
maintenance, Patchwork grants and commit rights can be restored.
References
----------
Much of this was inspired by/copied from the committer policies of:
- `Chromium <https://chromium.googlesource.com/chromium/src/+/main/docs/contributing.md>`_;
- `WebKit <https://webkit.org/commit-and-review-policy/>`_;
- `Mozilla <https://www.mozilla.org/hacking/committer/>`_.