docs: add LICENSE-CRITERIA.md as project licensing policy

Introduce LICENSE-CRITERIA.md, which describes the licensing requirements
the project applies to firmware submissions. The document explains which
grants a license must provide, the restrictions the project accepts, and
how new license texts are reviewed. It is written for hardware vendors
and their legal teams as well as for maintainers evaluating submissions.

Wire it into the existing documentation: README.md gains a "Licensing
requirements" subsection linking to the new document and its Quality
section defers to it rather than restating the criteria inline; AGENTS.md
references it for license-acceptability decisions and updates the
recommended file-naming convention (prefer LICENSE.<vendor> for new
files); check_whence.py adds LICENSE-CRITERIA.md to the known_files
allowlist so make check continues to pass.

Assisted-by: Claude Opus 4.8 (claude-opus-4-8[1m])
Signed-off-by: Josh Boyer <[email protected]>
This commit is contained in:
Josh Boyer
2026-06-29 20:23:52 +00:00
committed by Josh Boyer
parent 7671a51d9c
commit 94136c3e73
4 changed files with 352 additions and 15 deletions
+14 -5
View File
@@ -3,6 +3,9 @@
Guidance for AI coding agents (Claude Code, Codex, etc.) working in this
repository. Humans should start with [README.md](README.md); this file
restates the contribution rules in the operational order an agent needs them.
License-acceptability questions — whether a particular license text is
acceptable for inclusion — are governed by
[LICENSE-CRITERIA.md](LICENSE-CRITERIA.md).
## What this repository is
@@ -39,7 +42,10 @@ Upstream lives at <https://gitlab.com/kernel-firmware/linux-firmware.git>.
2. **Never invent license information.** The license and the redistributability
of a blob are facts that come from the firmware's owner — usually conveyed in
the submitter's commit and `Signed-off-by`. If you don't have it, don't guess.
Surface the gap to the user instead.
Surface the gap to the user instead. When evaluating whether a license *text*
is acceptable, apply the criteria in
[LICENSE-CRITERIA.md](LICENSE-CRITERIA.md) sections 5.1–5.3 — do not guess
at acceptability, and do not fabricate the underlying license facts.
3. **Always run `make check` before considering a change complete** (see below).
4. **Preserve the `Signed-off-by` line.** It is a legal attestation of the right
to redistribute. Never add, fabricate, or alter one on someone's behalf.
@@ -55,10 +61,13 @@ Upstream lives at <https://gitlab.com/kernel-firmware/linux-firmware.git>.
its license. Group it with related entries; keep the file roughly ordered as
the surrounding content is.
3. If the firmware needs a new license, the license text **must** go in the
`LICENSES/` directory as `LICENSES/LICENSE.<vendor>` (or
`LICENSES/LICENCE.<vendor>` — both spellings exist in the tree). Reference
it from `WHENCE` with `See LICENSE.<vendor> for details.` using the bare
filename; `check_whence.py` resolves it under `LICENSES/`.
`LICENSES/` directory. Prefer `LICENSES/LICENSE.<vendor>` for new files
(`LICENSES/LICENCE.<vendor>` also exists in the tree and is still accepted,
but new files should use the `LICENSE.<vendor>` spelling). Reference it from
`WHENCE` with `See LICENSE.<vendor> for details.` using the bare filename;
`check_whence.py` resolves it under `LICENSES/`. The license text must meet
the criteria in [LICENSE-CRITERIA.md](LICENSE-CRITERIA.md) section 5; new
license texts require maintainer review (see section 7).
4. Run `make check`.
5. Commit with a `Signed-off-by` from someone authoritative on the license,
and — if an agent helped produce the change — a trailer noting AI
+314
View File
@@ -0,0 +1,314 @@
# Firmware License Requirements for linux-firmware Submissions
This document describes the licensing requirements for firmware submitted to the
linux-firmware repository. It is written for hardware vendors and their legal
teams preparing a first submission or drafting a new license text. It explains
which licenses the project accepts, the criteria a license must meet, and how
new license texts are reviewed.
These requirements apply to new firmware submissions and to newly introduced
or materially changed license terms. They are not a retroactive judgment on
firmware already in the repository: existing files, and the license texts
already in `LICENSES/`, are unaffected.
Nothing in this document is legal advice. It describes the policy of the
linux-firmware project.
---
## 1. Why licensing is strict here
The purpose of this repository is unrestricted redistribution. Anyone may copy
the firmware onward to anyone else — recipients who have no relationship with
your company and have signed nothing. This is not specific to operating systems
or any class of redistributor.
A license therefore has to grant its rights to *everyone*, automatically, with
no signatures, registration, click-through, or payment. A license that works
for your direct customers but not for an arbitrary downstream recipient cannot
be accepted. This document describes the bar the project applies to keep that
unrestricted redistribution intact.
## 2. Firmware covered by this policy
This policy covers firmware images and related device data loaded by the
Linux kernel, a kernel driver, or a device the kernel supports. A submission
should be necessary for hardware support, device operation, or boot, in
service of open-source kernel or driver functionality.
A submission must be a standalone firmware image or device-data file — not a
host application, shared library, kernel driver, or other userspace or
operating-system component. Those carry their own licensing in their own
projects; this repository is only for the firmware that hardware needs to
function.
Firmware may be binary-only. Source is welcome whenever the firmware's owner
can provide it, but a binary-only image is acceptable as long as its license
meets the criteria in section 5.
If firmware is offered under a license requiring source availability — a member
of the GPL family, for example — the submission must satisfy that license's
source-code obligations. Do not label a binary-only image as GPL, or under any
other license requiring source availability, unless the corresponding source is
included (see section 4).
## 3. Quick checklist for vendors
Before you submit, confirm all of the following:
- [ ] The license grants **royalty-free redistribution** of the firmware files
by anyone, whether or not they incorporate the files into a product,
with no further permission required.
- [ ] The license grants **royalty-free use** of the firmware with the
associated hardware.
- [ ] The license includes an **explicit or implicit patent grant** sufficient
for end users to operate the device with full functionality.
- [ ] The license text is **self-contained** — it does not reference or depend
on a purchase agreement, EULA, NDA, support contract, or any document not
included in the repository.
- [ ] There are **no confidentiality terms** anywhere in the license, the
commit, the merge request, or the email used to submit it.
- [ ] There are **no fees, royalties, registration, click-acceptance, audit
rights, or reporting obligations** imposed on redistributors or users.
- [ ] If the firmware is under the **GPL or another copyleft license, the
corresponding source code is included** in the submission.
- [ ] You are **reusing your company's existing license file** in `LICENSES/`
if one exists, rather than introducing a new variant.
- [ ] The commit carries a **Signed-off-by from someone with authority over
the firmware's licensing** (typically within the company that owns or
controls the firmware).
- [ ] The `WHENCE` entry states the license and that the files are
redistributable, and `make check` passes.
If every box is checked, your submission is routine. If a new or modified
license text is involved, read section 7.
## 4. Licenses the project accepts
### 4.1 Existing license texts already in the repository (preferred)
The `LICENSES/` directory contains every license text currently in use, both
standard open-source licenses (e.g. `Apache-2.0`, `GPL-2.0`, `GPL-3.0-only`)
and vendor-specific redistributable firmware licenses (`LICENCE.<vendor>` /
`LICENSE.<vendor>` files).
**If your company already has a license file in `LICENSES/`, reuse it.** New
firmware files from the same vendor should reference the existing license in
their `WHENCE` entry. Do not submit per-product or per-file license variants;
proliferation of near-identical texts multiplies review burden for everyone
who has to evaluate them.
### 4.2 Standard open-source licenses
Firmware offered under a well-known OSI/FSF license (MIT, BSD-2/3-Clause,
Apache-2.0, GPL-2.0, etc.) is welcome and is the easiest path through review.
One important caveat: **copyleft licenses carry source code obligations**, and
a submission under such a license should include the corresponding source code.
### 4.3 Proprietary redistributable firmware licenses
Most firmware in the repository is under vendor-specific proprietary licenses.
These are acceptable when they grant the rights in section 5 and confine their
restrictions to those in section 5.2.
## 5. Criteria a license must meet
### 5.1 Required grants
A firmware license must, at minimum:
1. **Permit redistribution, royalty-free, by anyone — unconditionally.** The
grant must not be contingent on incorporating the firmware into a product,
operating system, or anything else, because recipients are free to copy the
firmware onward whether or not they build anything from it. A grant scoped
to product incorporation does not reach those bare redistributors or the
downstream archives and mirrors they create. Grants limited to a named
licensee, to "authorized partners," or contingent on a separate agreement
are likewise not acceptable.
2. **Permit use with the associated hardware, royalty-free.** Recipients must
be able to actually load and run the firmware on the device without further
permission or payment.
3. **Include a patent grant adequate for device operation.** The upstream
project requires that "redistributable" includes an implicit or explicit
patent license to end users sufficient for full functionality of the device
with the firmware. If your standard license text is silent on patents,
expect this to be raised in review; an explicit grant avoids the question.
4. **Permit copying necessary for distribution mechanics** — mirroring,
inclusion in install media and container/cloud images, and packaging
(compression, packaging-format transformation) — even where modification of
the firmware image itself is prohibited.
5. **Be perpetual and irrevocable for distributed copies.** A license that the
vendor can revoke at will, or that expires, makes every downstream archive
and released distribution image retroactively non-compliant and is not
acceptable.
### 5.2 Restrictions that are acceptable
The project accepts the following restrictions in firmware licenses:
- **Prohibition on modification** of the firmware image.
- **Prohibition on reverse engineering, disassembly, or decompilation.**
- **Restriction of use to the vendor's associated hardware** (the hardware the
firmware was designed for).
- **Requirement that the license text accompany redistributed copies.**
- **Warranty disclaimers and limitations of liability.**
- **Trademark non-grants** (the license conveys no trademark rights).
- Any restriction that would already be acceptable in an ordinary
distribution-approved software license.
- **Export-control notices** that inform recipients of applicable law. These
are tolerated when they are informational; clauses that convert export
compliance into an affirmative certification, reporting, or indemnification
obligation on redistributors are not.
### 5.3 Terms that will cause rejection
A license containing any of the following will not be accepted:
- "Internal use only," evaluation-only, or any grant that excludes
redistribution.
- Redistribution grants scoped to "as part of" a product, operating system,
or distribution. Older license files in the tree contain such language; new
licenses must permit redistribution by anyone, product or not (see 5.1).
- Fees, royalties, or per-unit accounting of any kind.
- **Confidentiality or non-disclosure terms.** Note that this applies to the
submission as well as the license: per the project README, a submission
email, patch, or merge request carrying a corporate confidentiality
statement will never be accepted. Make sure your mail system does not append
one.
- Requirements for click-through acceptance, registration, account creation,
or execution of a separate agreement before use or redistribution.
- Grants limited to named licensees or to parties with an existing business
relationship with the vendor.
- Audit rights, usage reporting, or indemnification obligations imposed on
redistributors or users.
- Termination at the vendor's convenience, or time-limited grants.
- Field-of-use restrictions beyond association with the vendor's hardware
(e.g. "non-commercial only," "not for use in competing products,"
geographic restrictions).
- Choice-of-law/venue or arbitration clauses that impose affirmative
obligations on passive recipients. (A simple governing-law statement is
usually tolerated; mandatory arbitration with fee-shifting is not.)
- Copyleft-licensed binaries without corresponding source (see 4.2).
- Terms that attempt to bind the linux-firmware project or kernel.org to any
obligation. The repository is a conduit; it cannot accept duties on your
behalf.
## 6. Mechanics: where license information lives in a submission
Every submission must encode its licensing in the repository's standard
structures so that automated tooling and downstream packagers can consume it.
**The `WHENCE` file.** Every firmware file in the tree has an entry in
`WHENCE` documenting its origin and licensing. A typical entry:
```text
Driver: foo -- FooCorp FOO-1234 Wireless Adapter
File: foocorp/foo1234.bin
Version: 2.7.1
Licence: Redistributable. See LICENSE.foocorp for details.
```
The `Licence:` line must clearly state the license and that the firmware is
redistributable. For standard licenses, name the license (e.g.
`Licence: GPL-2.0`, with source files listed). Optional `Version:` and `Info:`
lines, and `Link:` entries for symlinks, complete the entry.
**The `LICENSES/` directory.** If the license text is more than a short
statement, it must be placed as a separate file in `LICENSES/` and referenced
from `WHENCE` (e.g. "See LICENSE.foocorp for details"). The preferred naming
convention for new vendor license files is `LICENSE.<vendor>`; both
`LICENSE.<vendor>` and `LICENCE.<vendor>` spellings exist in the tree and are
accepted, but new files should use `LICENSE.<vendor>`. Standard licenses use
their SPDX-style name (e.g. `GPL-2.0`). One file per vendor license text —
reuse it across all your firmware.
**Signed-off-by.** Every commit must include a `Signed-off-by:` line from
someone with authority over the licensing of the firmware — typically a person
within the company that owns or controls it. This is the project's provenance
record: it attests that the submitter has the right to submit the firmware
under the stated license and that it may be redistributed under those terms.
If corporate infrastructure makes submitting from a company account difficult,
the Signed-off-by must still use the company address; the submission itself
may come from a personal address with the company address on CC.
Firmware must be submitted by the vendor that owns or controls it, or with
the vendor's explicit participation. Third-party submissions made without
vendor involvement will not be accepted: either the commit must carry a
`Signed-off-by` from the vendor, or the vendor must be copied on the
submission and acknowledge it.
**Validation.** Run `make check` before submitting; `check_whence.py` verifies
that `WHENCE` and the tree agree. CI runs the same checks on merge requests.
**Commit message.** Where possible, include a changelog of what changed in the
firmware itself. For binary files, the commit message is usually the only
human-readable record of a change. If an AI tool assisted in producing the
contribution, disclose it with an `Assisted-by:` (or similar) trailer in
addition to the Signed-off-by.
**Submission paths.** Open a merge request on the upstream GitLab project, or
send a git binary diff or pull request to `[email protected]`.
## 7. How new license texts are reviewed
This process applies when a submission introduces a license text not already
present in `LICENSES/`, or modifies an existing one.
1. **Flag it.** State prominently in the merge request or cover letter that
the submission introduces a new license text. Unflagged new licenses delay
review for the whole series.
2. **Submit the complete text** as a `LICENSES/LICENSE.<vendor>` file in the
same MR as the firmware it covers, referenced from the `WHENCE` entries.
The text must unambiguously identify the copyright holder and licensor.
3. **Maintainer review.** Maintainers review the text against section 5. They
are applying project policy, not giving your company legal advice; the
burden of ensuring the license says what you intend rests with your counsel.
4. **Outside consultation.** For novel terms, maintainers may seek additional
legal input before deciding. Vendors should expect questions and,
occasionally, requests for clarification from someone able to speak
authoritatively for the licensor.
5. **Outcomes.** A new license is accepted as-is, accepted after the vendor
issues a clarified or corrected text, or declined with the problematic
terms identified. Once accepted, the text becomes the vendor's canonical
license file and is treated as settled precedent — subsequent submissions
reusing it verbatim need no license review.
6. **Relicensing existing firmware.** The firmware is the submitter's
intellectual property, and the project does not control its licensing
beyond applying the section 5 criteria. A vendor may relicense their own
firmware whenever their existing license permits, submitting the new text
as they would any license change; the project's only requirement is that
the replacement still meets section 5. Two mechanical consequences are
worth being deliberate about:
- **One license file governs every firmware that references it.** A
vendor's firmware typically points at a single `LICENCE.<vendor>` file,
so editing that file changes the terms for *all* of it at once. To place
new firmware under different terms while leaving existing firmware as-is,
add a distinct license file for the new terms and point only the new
firmware's `WHENCE` entry at it.
- **Copies already distributed keep their original terms.** This follows
from copyright, not project policy: a grant made under the prior
license — which the criteria require to be irrevocable for distributed
copies (5.1) — cannot be withdrawn from copies already received, and any
mirror or archive that has not taken the update still carries the text it
was distributed with. Relicensing is forward-looking in effect, whatever
the current tree shows.
Review of a routine firmware update against an existing license is fast.
Review of a new license text takes as long as it takes — maintainers are
volunteers, and novel legal text takes longer than routine updates. Vendors
can compress the timeline more than anyone else can, by starting from an
already-accepted license text (their own or structurally similar ones in
`LICENSES/`) instead of novel drafting. Shorter texts also review faster: the
most reviewable licenses in `LICENSES/` are under a page, and every
additional clause adds burden for everyone who must evaluate it.
---
## References
- linux-firmware repository and README:
<https://gitlab.com/kernel-firmware/linux-firmware>
+23 -10
View File
@@ -10,6 +10,18 @@ The upstream repository is located at <https://gitlab.com/kernel-firmware/linux-
## Submitting firmware
### Licensing requirements
All firmware submitted to this repository must be redistributable to anyone,
royalty-free, without restrictions beyond those listed in
[LICENSE-CRITERIA.md](LICENSE-CRITERIA.md). Read that document before preparing
a submission — it describes the grants a license must provide, the restrictions
the project accepts, and how new license texts are reviewed. Vendors with an
existing license file in `LICENSES/` should reuse it; new license texts require
explicit maintainer review as described in `LICENSE-CRITERIA.md` section 7.
### Submission paths
To submit firmware to this repository, please do one of the following:
* open a MR [upstream](https://gitlab.com/kernel-firmware/linux-firmware)
@@ -31,6 +43,12 @@ the `Signed-off-by` line in the commit should still be via the company
address, but the submitter can use a personal address with the company address
on CC for the MR or patch contribution.
Firmware must be submitted by the vendor that owns or controls it, or with
the vendor's explicit participation. Submissions from third parties acting
without vendor involvement will not be accepted: either the commit must carry
a `Signed-off-by` from the vendor, or the vendor must be copied on the
submission and acknowledge it.
### AI assisted contributions
AI assisted contributions are welcome. If a commit was aided by or generated by
@@ -42,16 +60,11 @@ is in addition to, and does not replace, the `Signed-off-by` requirement above.
## Quality
If your commit adds new firmware, it must update the `WHENCE` file to
clearly state the license under which the firmware is available, and
that it is redistributable. Being redistributable includes ensuring
the firmware license provided includes an implicit or explicit
patent grant to end users to ensure full functionality of device
operation with the firmware. If the license is long and involved, the
license text may be kept in a separate file rather than inline in `WHENCE`.
Any such separate license file **must** be placed in the `LICENSES/`
directory and referenced from the `WHENCE` file (IE _'See `LICENSE.foo` for
details.'_).
If your commit adds new firmware, it must update the `WHENCE` file to clearly
state the license and that the firmware is redistributable. The full criteria
a license must meet are in [LICENSE-CRITERIA.md](LICENSE-CRITERIA.md) sections
5 and 6. If the license text is long, place it in the `LICENSES/` directory and
reference it from `WHENCE` (e.g. _'See `LICENSE.foo` for details.'_).
Where possible, the commit message should also include a changelog of the
firmware itself — what changed in this revision — since for binary firmware
+1
View File
@@ -77,6 +77,7 @@ def main():
known_files = set(name for name in whence_list if not name.endswith("/")) | set(
[
"AGENTS.md",
"LICENSE-CRITERIA.md",
".codespell.cfg",
".editorconfig",
".gitignore",