The software that ships with a chip, from the boot ROM in its masks to the drivers, SDK and updates customers rely on: requirements and the hardware-software interface, development on virtual platforms and emulation before silicon, boot ROM freeze, firmware, drivers and board support, security, signing and secure update, SDKs and toolchains, bring-up on first silicon, validation, production release, and maintenance and vulnerability response until the end of support.
Firmware and software stack lifecycle: 12 stages, 14 gates of its own and 3 hand-offs to the Product lifecycle, from Software Requirements & Platform Planning to Final Release & End of Software Support.
12 stages, 14 gates of its own and 3 hand-offs to the Product lifecycle. Each stop opens its stage; each sign opens its gate. Point at a stop or tab to it to read what the stage is for. What the codes mean
In collaboration with The Digital Electronics Blog (opens in a new tab)
An outlined sign with an arrow is a hand-off: the gate is owned by the Product lifecycle, where this lifecycle hands its work on.
In collaboration with The Digital Electronics Blog (opens in a new tab)
Deciding what software has to ship with the chip and for whom: the operating systems, environments and toolchains to support, the boot and security features customers expect, the reference software and SDK scope, the support period, and the plan for developing it before silicon exists.
Software concept approval gate, owned by the Product lifecycle (Concept approval)Software requirements agreed gate
Designing the software stack and agreeing its interface with the hardware: the boot flow and chain of trust, the memory map, the register and interrupt interface, the split of work between boot ROM, firmware on internal cores and drivers on the host processor, the security architecture and the build and release approach.
An outlined sign with an arrow is a hand-off: the gate is owned by the Product lifecycle, where this lifecycle hands its work on.
Writing and running software before the chip exists, on virtual platforms, RTL simulation, emulation and FPGA prototypes, so boot code, firmware and drivers are ready for first silicon and the software finds hardware bugs while they can still be fixed in the design.
Finishing the code that is built into the chip's masks: the boot ROM that starts the chip, selects the boot source, verifies the first loader against keys or key hashes held in the chip, and offers a recovery path.
Building out the feature set on models: firmware for the chip's internal controllers such as power management, security and system control cores, the operating system drivers on the host processor, and the board support package that brings an operating system up on the reference board, ending in an alpha release.
Making the software stack secure to ship: reviewing it against the threat model, setting up the signing service and the key management that production images need, designing secure update with anti-rollback and recovery, and agreeing how vulnerabilities will be handled after release.
Packaging what customers build with: the compiler toolchain and debugger support for the chip's cores, the software development kit with libraries, headers and examples, reference applications, and the documentation that lets a customer team start, released first to early-access customers.
Running the software on real silicon for the first time: first boot on the reference board, then firmware, drivers and the operating system, separating hardware bugs from software bugs, correlating with the models, and writing the workarounds and errata entries that silicon issues need.
Proving the release candidate works on silicon across boards, configurations, operating systems and use cases: functional, performance, power, stress, security and update testing on hardware-in-the-loop rigs, compliance and interoperability testing, and beta use by sampling customers.
Releasing the software that ships with production parts: production-signed images, the SDK and reference software, release notes, the software bill of materials and licence compliance record, developer documentation and porting guides, with the update service ready before customers ship.
Keeping the software working and secure for as long as the chip is supported: maintenance releases with fixes and new silicon steppings, security updates delivered through the secure update path, vulnerability triage and advisories, operating system and toolchain upgrades, and long-term support branches.
Maintenance release gateSupport plan review gate, owned by the Product lifecycle (Lifecycle review)
Closing software support in an orderly way: announcing the end of support, shipping the final release and final security advisory, archiving source, build environments and signing records so the software can still be rebuilt if it must be, and giving customers a migration path.
Final release announced gateEnd of software support gate, owned by the Product lifecycle (End of support)
The full lifecycle detail, with its charts, flows, tables and every section, is for registered members. Registration is free and takes a minute. You come back to this page afterwards.