TL;DR
- Yunsilicon has submitted a 15-patch driver series to the Linux Kernel Mailing List (LKML) to upstream native driver support for its converged network adapters and Data Processing Units (DPUs).
- The patch series targets dual-function PCI Express devices operating under PCI vendor ID
0x1f67, offering combined 802.3 Ethernet and InfiniBand-based Remote Direct Memory Access (RDMA) capabilities. - The software architecture uses the Linux auxiliary bus framework (
auxiliary_device), splitting the stack across three GPLv2 modules:xsc_pci,xsc_eth, andxsc_ib. - A single probe by the core PCI driver (
xsc_pci) manages physical hardware queues, interrupts, and resource pools while publishing sub-devices for upper-layer Ethernet (NAPI,page_pool) and RDMA verbs. - Engineers can evaluate the driver using kernel options
CONFIG_YUNSILICON_XSC_PCI,CONFIG_YUNSILICON_XSC_ETH, andCONFIG_INFINIBAND_XSCas patch iterations move through upstream review.
Chinese semiconductor startup Yunsilicon, established in 2021, has submitted an open-source driver patch series to the Linux Kernel Mailing List (LKML) for inclusion in the mainline kernel. The yunsilicon linux driver implementation provides host software support for the vendor’s high-performance converged network adapters and Data Processing Units (DPUs). Designed for dual-function PCI Express (PCIe) hardware operating under PCI vendor ID 0x1f67, the patch series establishes a modular driver framework that drives high-throughput Ethernet traffic alongside InfiniBand-based Remote Direct Memory Access (RDMA) operations within a single controller architecture.
The upstream submission, initially published as an early RFC draft in October 2026 and refined into a structured 15-patch proposal with an explanatory cover letter in November 2026 according to a Phoronix report on Yunsilicon LKML submission, marks the public release of software under internal development since 2021. Licensed under the General Public License version 2 (GPLv2), the XSC driver stack replaces out-of-tree vendor code with a modular kernel integration model. This initiative aligns Yunsilicon with open-source kernel standards required by enterprise cloud operators, hyperscalers, and sovereign compute facilities.
Rather than registering monolithic driver instances directly against separate PCIe functions or creating tightly coupled monolithic drivers, Yunsilicon structures its Linux driver around the kernel’s auxiliary bus framework. A primary core driver, xsc_pci, binds to the underlying hardware physical function (PF), initialises registers, manages interrupt vectors, and allocates base queue resources. It then exports specialized sub-devices for upper-layer network (xsc_eth) and InfiniBand (xsc_ib) drivers. This design decouples PCI hardware lifecycle management from upper-layer network personalities, preventing resource contention and simplifying live driver reloads.
1. Yunsilicon Submits Open-Source XSC Driver to Mainline Kernel
Founded in 2021, Yunsilicon has focused on developing high-bandwidth network interface cards (NICs) and DPUs engineered for data centre workloads, high-frequency trading networks, and artificial intelligence clusters. For several years, deployment of Yunsilicon hardware depended on internal, out-of-tree host driver modules. The transition to upstream LKML submission signifies a deliberate push to integrate the software directly into distribution kernels (such as Red Hat Enterprise Linux, Ubuntu Server, and SUSE Linux Enterprise), eliminating out-of-tree DKMS (Dynamic Kernel Module Support) maintenance overhead for infrastructure operations teams.
The patch series submission timeline highlights an active review cycle on the mailing list:
- October 2026: Initial draft of the XSC driver posted to LKML to gather preliminary maintainer feedback regarding architectural layouts and hardware initialization sequences.
- November 2026: Submission of a refined, 15-patch series complete with a cover letter detailing driver modularisation, PCI resource lifecycle management, and subsystem registration flows.
The targeted hardware consists of dual-function PCIe silicon identified by PCI vendor ID 0x1f67. In converged enterprise adapters, dual-function hardware presents physical endpoints that handle packet processing for standard IEEE 802.3 Ethernet framing while simultaneously running RDMA engines (such as RoCEv2 or native InfiniBand transport) over shared physical transceivers and media access control (MAC) layers.
Hardware Specifications and Mainline Targets
The public patch series and cover letter do not disclose specific commercial product model numbers, maximum throughput limits (e.g., 100GbE, 200GbE, or 400GbE), physical memory layouts, or latency benchmarks for Yunsilicon silicon. Furthermore, access restrictions on Yunsilicon corporate web infrastructure limit external verification of silicon microarchitecture details or target manufacturing process nodes. The target mainline Linux kernel merge window (e.g., a future 6.x cycle) remains unconfirmed pending LKML maintainer feedback.
2. Auxiliary Bus Architecture in Converged Network Adapters
Modern enterprise DPUs and converged network adapters combine multiple distinct computing workloads onto a single PCIe endpoint. Historically, driver architects solved this by presenting multiple PCIe physical functions (PFs) or virtual functions (VFs) to the operating system, or by engineering monolithic kernel drivers that registered with both the netdev and infiniband subsystems inside a single large source file. Both legacy approaches introduce engineering trade-offs:
- Multi-PF Hardware Layouts: Consumes finite PCIe bus numbers, multiplies configuration space overhead, and duplicates base hardware state initialisation across multiple driver probes.
- Monolithic PCIe Drivers: Severely couples upper-layer network subsystems. Tearing down an Ethernet netdev interface requires resetting the underlying PCIe device, which destabilises active RDMA queue pairs operating over the same silicon physical layer.
To resolve this structural problem, the Linux kernel introduced the auxiliary bus subsystem (drivers/base/auxiliary.c). The auxiliary bus allows a primary PCI driver to claim the hardware PCIe function, execute base initialization, and subsequently spawn auxiliary child devices on an internal virtual bus. Specialized child drivers then bind to these auxiliary devices independently.
+-----------------------------------------------------------------------+
| PCIe Hardware (Vendor ID 0x1f67) |
+-----------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------+
| xsc_pci (PCI Core Driver) |
| - Binds to Physical Function (PF) |
| - Configures MMIO, MSI-X Interrupts, Command Queues, Event Queues |
| - Manages HW Resource Pools: CQs, QPs, SRQs |
+-----------------------------------------------------------------------+
| |
| Spawns Auxiliary Device 1 | Spawns Auxiliary Device 2
v v
+-------------------------------------+ +-------------------------------+
| xsc_eth (Ethernet Driver) | | xsc_ib (InfiniBand/RDMA) |
| - Binds to auxiliary_device | | - Binds to auxiliary_device|
| - Registers netdev | | - Registers ib_device |
| - Manages NAPI, page_pool, RSS | | - Provides RDMA Verbs |
+-------------------------------------+ +-------------------------------+
|
v
(Queries netdev state & GIDs)
In the Yunsilicon XSC architecture, xsc_pci serves as the parent bus driver. It completes PCI probing once, configures DMA execution masks, maps MMIO BAR registers, and sets up global interrupt distribution. Once operational, xsc_pci instantiates auxiliary devices for Ethernet and RDMA personalities. The upper-layer drivers—xsc_eth and xsc_ib—bind to these auxiliary abstractions without directly executing PCI MMIO mapping operations or hardware resets.
This decoupling provides three operational benefits for high-performance data center deployments:
- Single Hardware Probe: Hardware registers, command queues, and event channels are initialised once during boot, reducing driver loading times and eliminating probe race conditions.
- Independent Lifecycle Management: Network operators can unload or restart the
xsc_ethEthernet module to apply parameter updates without interrupting active memory transfers managed byxsc_ibon the RDMA subsystem. - Resource Aggregation: Low-level hardware resources—such as Completion Queue (CQ) IDs, Queue Pair (QP) contexts, and Shared Receive Queue (SRQ) handles—are maintained in shared memory allocation pools by
xsc_pci, preventing cross-driver resource fragmentation.
3. Core Subsystem Analysis: Deconstructing xsc_pci
The foundation of the Yunsilicon driver suite is xsc_pci, enabled via the kernel configuration flag CONFIG_YUNSILICON_XSC_PCI. Patches 02 through 06 of the upstream patch series establish this core controller driver. Its primary responsibility is managing the hardware physical function (PF), setting up underlying communication primitives, and providing a unified resource controller for attached auxiliary drivers.
Command Queues and Event Queues
Upon probing a supported PCIe device under vendor ID 0x1f67, xsc_pci sets up hardware-level command queues (CMDQ) and event queues (EQ). The command queue functions as a low-latency mailbox interface, allowing the host CPU to send synchronous control-plane instructions to the device firmware—such as creating hardware queue pairs, configuring VLAN filters, or altering MAC address tables.
Event queues process asynchronous hardware notifications. When the adapter processes inbound packets, encounters line errors, or completes an RDMA transfer, it triggers an event entry on the corresponding EQ. The xsc_pci driver parses these events and dispatches notifications to appropriate kernel subsystems or upper-layer auxiliary devices.
Interrupt Handling and Register Access
The core driver maps the device’s Memory-Mapped I/O (MMIO) BARs into host kernel address space and allocates Message Signaled Interrupts (MSI-X) vectors. Interrupt processing is distributed across available CPU cores by mapping individual event queues to specific MSI-X vectors. The register access layer abstracts physical hardware offsets, enforcing atomic register writes and memory barriers to ensure safe concurrency across multi-threaded driver code paths.
Resource Pool Management
A key responsibility of xsc_pci is managing low-level resource tracking tables for high-speed hardware contexts. These include:
- Completion Queues (CQ): Allocates memory regions and unique IDs for hardware completion rings shared between host OS buffers and adapter engines.
- Queue Pairs (QP): Manages the lifecycle and state allocation of send and receive work queues used for hardware-accelerated DMA transfers.
- Shared Receive Queues (SRQ): Tracks shared ingress memory pools designed to minimise memory footprint under high concurrency across thousands of connection endpoints.
| Module Name | Kernel Config Flag | Target Device / Bus | Primary Subsystem Integrations |
|---|---|---|---|
xsc_pci |
CONFIG_YUNSILICON_XSC_PCI |
PCIe Physical Function (Vendor 0x1f67) |
PCI Core, MSI-X, DMA Engine, Auxiliary Bus Provider |
xsc_eth |
CONFIG_YUNSILICON_XSC_ETH |
Auxiliary Device (published by xsc_pci) |
Linux netdev, NAPI, page_pool, RSS, Checksum Offload |
xsc_ib |
CONFIG_INFINIBAND_XSC |
Auxiliary Device (published by xsc_pci) |
InfiniBand Core, RDMA Verbs, sysfs, netdev event hooks |
4. Ethernet Stack Integration: Deconstructing xsc_eth
Layered directly above the PCI core driver, xsc_eth (controlled by CONFIG_YUNSILICON_XSC_ETH) implements standard Linux networking functionality. Patches 07 through 09 contain the logic required to register network devices (netdev) and wire up high-performance ingress and egress packet paths.
NAPI and page_pool Drivers
To support high frame rates without overwhelming host processors with interrupt storms, xsc_eth incorporates the Linux New API (NAPI) polling subsystem. Under heavy packet loads, the driver switches from per-packet hardware interrupts to a polled budget model. The execution context executes inside softirq processing loops, pulling packet descriptors off physical ring buffers in batches.
For memory allocation on the ingress path, xsc_eth integrates with the kernel’s page_pool API. Traditional network drivers allocate page-sized buffers via standard kernel page allocators (alloc_pages) on a per-packet basis, incurring cache misses, TLB management overhead, and atomic reference counting lock contention. The page_pool infrastructure allows xsc_eth to maintain a high-speed lockless ring of recycled memory pages assigned directly to RX hardware rings. When a frame is consumed by upper-layer socket buffers and freed, the underlying memory page returns immediately to the driver’s page pool without undergoing full kernel deallocation cycles.
Hardware Offloads and Statistics
The xsc_eth driver exposes several hardware offload mechanisms to the Linux netdev layer:
- Receive Side Scaling (RSS): Configures multi-queue hardware hashing to distribute inbound IP socket flows evenly across available host CPU cores, eliminating packet processing bottlenecks on single cores.
- Checksum Offloading: Offloads TCP, UDP, and IP header checksum computation and validation directly to the hardware engine for both transmit (TX) and receive (RX) directions.
- Network Statistics Integration: Leverages hardware counters to report standard statistics (such as frame errors, dropped packets, byte counts, and queue depth metrics) to tools like
ethtoolandiproute2.
5. InfiniBand and RDMA Implementation: Deconstructing xsc_ib
The third tier of the Yunsilicon driver architecture is xsc_ib, compiled via CONFIG_INFINIBAND_XSC. Formed by patches 10 through 15 of the submission series, this module converts low-level hardware resource pools exposed by xsc_pci into standard Linux InfiniBand and Remote Direct Memory Access (RDMA) verbs.
ib_device Registration and Netdev Dependencies
Upon binding to its assigned auxiliary device, xsc_ib registers an ib_device handle with the Linux kernel InfiniBand core. Unlike standalone InfiniBand host channel adapters (HCAs), converged RoCE (RDMA over Converged Ethernet) adapters rely on physical Ethernet interfaces for physical link state management, MTU configuration, and IP-to-GID (Global Identifier) resolution.
Consequently, xsc_ib maintains an active coupling with the netdev instance registered by xsc_eth. When an administrator modifies interface link states, IP addresses, or VLAN tagging rules on the Ethernet interface, xsc_ib receives netdev event callbacks, updating its active GID tables and transport state contexts accordingly.
Verbs Implementation
The driver exposes standard verbs required by modern user-space RDMA frameworks, such as OpenFabrics Interfaces (OFI) and the Linux rdma-core userspace library:
- Protection Domains (PD): Isolates physical memory spaces, ensuring that registered memory regions can only be accessed by authorized Queue Pairs.
- Memory Regions (MR): Handles host virtual-to-physical memory page translation, pinning physical memory pages into RAM for zero-copy hardware DMA transfers over the PCIe bus.
- Completion Queues (CQ) & Shared Receive Queues (SRQ): Exposes low-latency completion signaling interfaces and shared ingress memory buffers to applications.
- Address Handles (AH): Resolves destination paths, MAC addresses, and routing parameters for unreliable datagram (UD) and reliable connection (RC) RDMA communication modes.
- Queue Pairs (QP): Manages data transfer operations (RDMA Read, RDMA Write, Atomic operations, and Send/Receive primitives) across hardware state machines (RESET, INIT, RTR, RTS).
Sysfs Diagnostics and Counters
The xsc_ib driver exposes operational metrics through the system sysfs hierarchy (typically under /sys/class/infiniband/xsc_0/). Engine performance counters—such as total RDMA read/write requests, packet retries, sequence error occurrences, and out-of-order delivery events—are available directly to system diagnostic utilities without requiring out-of-band management calls.
6. Upstreaming Dynamics and Open-Source DPU Ecosystem
The process of upstreaming a vendor driver to the mainline Linux kernel involves rigorous review by Linux networking maintainers (such as the netdev group) and RDMA subsystem maintainers. Historically, hardware vendors shipped out-of-tree binary modules or custom software stacks. However, this out-of-tree approach presents major challenges in modern enterprise environment:
- Kernel API Instability: Internal Linux kernel interfaces change across major versions. Out-of-tree modules regularly break when cloud operators update base enterprise kernels.
- Security and Audit Requirements: Enterprise security teams routinely reject closed-source or out-of-tree kernel modules due to memory safety risks, unverified binary blobs, and difficulty maintaining automated updates.
- Deployment Complexity: Out-of-tree drivers require custom build pipelines, external repository configurations, and DKMS complications across heterogeneous compute pools.
By transitioning its driver stack from private codebase development (in progress since 2021) to public LKML submissions in late 2026, Yunsilicon works to ensure native kernel compatibility. To achieve acceptance into the mainline tree, the vendor must meet strict code quality and design criteria:
- Strict Code Style Compliance: Adherence to kernel memory management patterns, avoidance of proprietary abstraction layers, and strict execution of Linux lockless data structures.
- Subsystem Feature Standardization: Leveraging standardized interfaces such as
page_pooland the auxiliary bus framework rather than creating vendor-specific memory allocators or internal bus abstractions. - Clean Module Separation: Clear isolation between base hardware initialization (PCI core), standard networking (netdev), and storage/RDMA fabrics (InfiniBand verbs).
7. Operational Guidance: Building, Testing, and Monitoring xsc Modules
For systems engineers, platform developers, and SREs working with early kernel releases or custom kernel builds containing the Yunsilicon driver patch series, the following procedures outline how to configure, verify, and diagnose the xsc module stack.
Kernel Configuration Parameters
To build the Yunsilicon driver stack from a patched kernel source tree, ensure the relevant kernel config flags are enabled in your kernel configuration (via make menuconfig or direct config file modification):
# Core PCI Driver (Required foundation)
CONFIG_YUNSILICON_XSC_PCI=m
# Network Stack Auxiliary Driver (Requires CONFIG_NETDEVICES, CONFIG_PAGE_POOL)
CONFIG_YUNSILICON_XSC_ETH=m
# RDMA / InfiniBand Auxiliary Driver (Requires CONFIG_INFINIBAND)
CONFIG_INFINIBAND_XSC=m
Hardware Identification and Module Verification
When physical hardware or hardware-emulated test suites are attached to the host PCIe bus, use lspci to verify device detection and binding under PCI vendor ID 0x1f67:
# Query PCIe devices matching Yunsilicon Vendor ID 0x1f67
$ lspci -nn -d 1f67:
# Example Output:
# 04:00.0 Ethernet controller [0200]: Yunsilicon Device [1f67:a001] (rev 01)
# 04:00.1 Ethernet controller [0200]: Yunsilicon Device [1f67:a001] (rev 01)
# Inspect bound kernel driver module for physical function
$ lspci -ks 04:00.0
# Expected Kernel Output:
# 04:00.0 Ethernet controller: Yunsilicon Device [1f67:a001] (rev 01)
# Subsystem: Yunsilicon Device [1f67:0001]
# Kernel driver in use: xsc_pci
# Kernel modules: xsc_pci
Inspecting Auxiliary Devices and Subsystem Links
Once xsc_pci binds to the physical function, verify that auxiliary sub-devices have been published to the system bus:
# Inspect registered auxiliary devices spawned by xsc_pci
$ ls -l /sys/bus/auxiliary/devices/
# Example Auxiliary Devices Output:
# xsc_pci.eth.0 -> ../../../devices/pci0000:00/0000:04:00.0/xsc_pci.eth.0
# xsc_pci.ib.0 -> ../../../devices/pci0000:00/0000:04:00.0/xsc_pci.ib.0
# Verify loading of upper-layer modules
$ lsmod | grep xsc
xsc_ib 98304 0
xsc_eth 81920 0
xsc_pci 147456 2 xsc_ib,xsc_eth
Network Diagnostics and RDMA Monitoring
To inspect network device parameters and evaluate ring allocations and hardware offload states, use ethtool and rdma tools:
# Display hardware offload features for the xsc network interface
$ ethtool -k eth1 | grep -E "checksum|receive-offload|rss"
# Extract custom driver hardware statistics
$ ethtool -S eth1 | grep -E "rx_page_pool|tx_packets|rx_dropped"
# Verify RDMA device status via iproute2 rdma tool
$ rdma dev show
# 1: xsc_0: node_type ca fw 1.0.000 netdev eth1 state ACTIVE
# Query sysfs RDMA diagnostics counters
$ cat /sys/class/infiniband/xsc_0/ports/1/hw_counters/lifespan
$ cat /sys/class/infiniband/xsc_0/ports/1/counters/port_rcv_packets
Deployment Warning: Testing Staging Patches
The patch series submitted in late 2026 represents upstream proposals undergoing LKML review. Do not deploy out-of-tree LKML patch revisions into production critical paths without prior validation in isolated staging environments. Driver module APIs and internal register structures may change prior to official inclusion in a stable Linux release.
Common Operational Mistakes
When compiling or operating systems using early builds of the XSC driver stack, engineers frequently encounter predictable integration pitfalls:
- Unloading Order Dependencies: Attempting to forcefully unload
xsc_pciviarmmod xsc_pciwhilexsc_ethorxsc_ibmodules remain active. The upper-layer auxiliary drivers hold active module reference counts. Always unload upper drivers (xsc_ib,xsc_eth) before removing the foundationalxsc_pcimodule. - Missing Kernel Dependencies: Compiling
xsc_ethorxsc_ibwithout enabling kernel-levelCONFIG_PAGE_POOLorCONFIG_INFINIBANDoptions causes build failures during symbol resolution phases. - GID Mapping Issues on RDMA: Attempting to establish RDMA queue pairs over
xsc_ibwhile the correspondingxsc_ethinterface is administratively down (ip link set dev eth1 down). RoCE routing contexts depend on active netdev operational states to resolve MAC and GID entries.
8. Key Takeaways on the Yunsilicon XSC Linux Driver
The submission of the Yunsilicon XSC Linux driver patch series to the LKML provides insight into modern network driver design for high-performance enterprise hardware. By separating hardware physical functions from network interface types, Yunsilicon implements a modular kernel integration structure built for scaled deployments.
Primary structural aspects of the XSC driver suite include:
- Auxiliary Bus Decoupling: Isolates physical hardware administration (PCI MMIO, MSI-X, resource queues) into a single master driver (
xsc_pci), allowing specialized drivers (xsc_eth,xsc_ib) to manage network interface types independently without duplicate initialization calls. - Modern Network Stack Integrations: Features
page_poolmemory allocation, NAPI interrupt suppression, Receive Side Scaling (RSS), and checksum offload abstractions for network operations. - Standardised InfiniBand and RDMA Implementation: Native verbs support (PD, MR, CQ, SRQ, AH, QP) integrated with host netdev event channels for RoCE execution paths.
- Upstream Vendor Alignment: Moves vendor codebase development out of proprietary, out-of-tree repositories into public LKML review channels, establishing native kernel compatibility for enterprise operating systems.
As the patch series moves through review iterations on the Linux kernel mailing list, Linux network maintainers and system architects can monitor patch series progression, verify hardware resource management flows under CONFIG_YUNSILICON_XSC_PCI, and track integration milestones ahead of mainline kernel inclusion.
Frequently asked questions
What hardware is supported by the Yunsilicon XSC Linux driver?
The Yunsilicon XSC driver supports converged network adapters and Data Processing Units (DPUs) manufactured by Yunsilicon. The software targets dual-function PCI Express devices operating under PCI vendor ID 0x1f67, providing integrated support for standard 802.3 Ethernet packet processing and hardware-accelerated InfiniBand or RoCE RDMA operations. Specific commercial model numbers and memory specifications have not been publicly disclosed in the driver patch series.
How does the Yunsilicon driver separate Ethernet and RDMA functionality?
The driver uses the Linux auxiliary bus framework (auxiliary_device). A core driver, xsc_pci, claims the physical PCIe device, initializes interrupts, and manages shared hardware queues. It then publishes distinct auxiliary devices on an internal kernel bus. The Ethernet driver (xsc_eth) and RDMA driver (xsc_ib) bind separately to these auxiliary devices, sharing physical hardware resources without requiring separate PCIe probes or hardware resets.
Which kernel mechanisms are used by xsc_eth for high-performance packet delivery?
The xsc_eth driver integrates with the Linux NAPI (New API) framework to poll incoming packets in batches during high load, mitigating CPU interrupt storms. For memory allocation, it uses the Linux page_pool infrastructure, which recycles memory pages for network frames to prevent latency spikes associated with frequent kernel page allocations and cache misses.
Is the Yunsilicon XSC driver open source?
Yes, the Yunsilicon XSC driver stack is licensed under the General Public License version 2 (GPLv2). The driver series was submitted directly to the Linux Kernel Mailing List (LKML) for formal review, aiming for complete inclusion in the mainline Linux kernel. This allows infrastructure engineers to inspect source code and deploy hardware without relying on out-of-tree binary modules.
Sources and further reading
This article was drafted with AI assistance from the publicly cited sources and passed automated checks for structure and sourcing. Verify critical details against the vendor advisories linked above before acting.