Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutRoadmapCareersInternshipsFAQContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • The NanoSoC Tour
  • Reading Path
  • SoC Glossary10
  • SoC Metrics Reference
  • SoC Cheatsheet
  • What SoC Integration Is12
  • Architecture and Budgets21
  • Memory Maps and Address Decode26
  • Interconnect and Bus Fabrics26
  • Clock and Reset Architecture24
  • Power Architecture21
  • Interrupts, DMA and Peripherals15
  • Memories, Boot and Security21
    • Memory Subsystem Integration
    • ECC and Error Handling
    • External Memory Controller Integration
    • Boot ROM and Boot Modes
    • eFuse and OTP
    • Secure Boot and Root of Trust
    • Security Architecture
      • The AxPROT Partition
      • Lifecycle States and Debug Locking
      • The Integrator Security Checklist
  • IP Integration and Handoff21
  • Top-Level Verification and Bring-up21
  • Package, Pads and I/O18
  • Chip Signoff and Tapeout18
  • SoC Interview Prep16
  • Capstone: Integrate NanoSoC14
Loading lesson

←Memories, Boot and Security
  1. Topics
  2. SoC Design
  3. Memories, Boot and Security
  4. Security Architecture

Part 8 of 14Part 8 of 14/Memories, Boot and SecurityAll levels

Security Architecture

Secure and non-secure partition with the AxPROT filter, lifecycle states, debug locking, and the integrator checklist.

  • 3topics
  • 3lessons

Every earlier topic in this section ends at the same question: what stops the wrong software from reaching the right hardware. The answer is the security architecture: a partition of masters and slaves into secure and non-secure, enforced by filters the integrator places and configures, managed across lifecycle states, and closed against debug escape. This topic works through the NanoSoC partition: the AxPROT filter, the secure-only slaves, the lifecycle ladder, and the checklist that proves the partition holds. It also teaches the one escape NanoSoC v1 still has: a master whose security attribute is a register that non-secure software can write. Until that is fixed the partition is not closed, and the lessons show the fix and the test that proves it. For the attribute theory behind the partition, the course points at the protocol-first-principles material on access attributes; for firewall placement, at its material on firewalls and filtering.

Lesson

After it you can...

The AxPROT Partition

Enforce the NanoSoC secure partition, predict the response of every cross-state access, and close the SBR attribute escape.

Lifecycle States and Debug Locking

Advance lifecycle states monotonically and lock debug by state.

The Integrator Security Checklist

Check attribute propagation, firewall placement and verification before signoff.

Suggested order: top to bottom. Draw the partition first, because lifecycle and checklists both assume its boundaries; then manage the states that open and close doors in it; then run the checklist that proves it holds. Readers from the secure-boot topic already know what the partition protects; this topic shows how.

Check yourself Why is the security architecture an integrator topic rather than a block topic?

Because no block sees the whole partition: each slave knows its own attribute, but only the integrator places the filters, assigns the states, routes the interrupts and locks the debug paths. The escapes live between blocks, which is exactly the integrator's ground.

Expect to draw the NanoSoC partition from memory: which slaves are secure-only, where the filters sit, and what a non-secure access to each returns. The first lesson is that drawing with the reasoning.

PreviousNext: The AxPROT Partition

Up next

Up nextThe AxPROT Partition

Sign in to save progress

Practice this lessonPrevious lessonReport an error

See also

  • Memory Subsystem Integration
  • ECC and Error Handling
  • External Memory Controller Integration