RISC-V Linux
Açık ISA ile özgür donanım.

00 RISC-V nedir?

RISC-V, UC Berkeley'de akademik bir proje olarak 2010'da başlayan, telif hakkı ve lisans ücreti olmayan, tamamen açık kaynaklı bir Komut Seti Mimarisidir (ISA). ARM veya x86'nın aksine RISC-V International üyesi olan herkes donanım veya yazılım üretebilir, ISA'yı genişletebilir.

ISA özgürlüğünün önemi

x86 Intel/AMD tarafından, ARM ise ARM Holdings (şimdi SoftBank ve halka açık) tarafından lisanslanır. Her iki mimaride de ciddi lisans bedelleri, NDA gerektiren donanım referans belgeleri ve kısıtlı özelleştirme imkânı söz konusudur. RISC-V bu kısıtlamaları tamamen ortadan kaldırır: spesifikasyon açık, donanım geliştirme serbesttir ve akademik çalışmalar kolaylaşır.

RISC-V International

RISC-V International, standartların yönetimini üstlenen kar amacı gütmeyen bir kuruluştur. Qualcomm, Google, NVIDIA, Intel, SiFive, Alibaba ve METU gibi 3500'den fazla üye kurumu bünyesinde barındırır. ISA spesifikasyonu GitHub'da (riscv/riscv-isa-manual) herkese açık tutulmaktadır.

Temel ve genişletilmiş extension'lar

Pratik bir Linux sistemi için minimum gereksinim RV64GC'dir: G = IMAFD, C = sıkıştırılmış komutlar. riscv64gc-linux-gnu şeklinde toolchain adlandırması bu kümeye karşılık gelir.

01 Privilege seviyeleri ve CSR'lar

RISC-V, güvenli çoklu yazılım yürütümü için üç ayrı ayrıcalık seviyesi tanımlar. Her seviye farklı CSR (Control and Status Register) setine sahiptir ve alt seviyeler üst seviyelere erişemez.

Privilege seviyeleri

  ┌─────────────────────────────────────────────────┐
  │  M-mode  (Machine)      — Firmware / OpenSBI    │  En yüksek ayrıcalık
  ├─────────────────────────────────────────────────┤
  │  S-mode  (Supervisor)   — Linux kernel          │  OS seviyesi
  ├─────────────────────────────────────────────────┤
  │  U-mode  (User)         — Kullanıcı uygulaması  │  En düşük ayrıcalık
  └─────────────────────────────────────────────────┘
    H uzantısı ile ekstra HS/VS/VU modları eklenir
    

Önemli CSR register'lar

Trap işleme akışı

# CSR'lara erişim assembly komutları:
# Okuma
csrr  a0, mhartid        # a0 = mhartid CSR değeri
csrr  a1, mcause         # trap nedenini oku

# Yazma
csrw  mstatus, a0        # mstatus = a0
csrrs a0, mstatus, t0   # a0 = mstatus; mstatus |= t0  (set bits)
csrrc a0, mstatus, t0   # a0 = mstatus; mstatus &= ~t0 (clear bits)

# Trap handler (M-mode):
# 1. mtvec → trap handler adresine dal
# 2. mcause oku → interrupt mı exception mı?
# 3. mepc kaydet → dönüş adresi
# 4. İşle, sonra mret ile geri dön

02 SBI — Supervisor Binary Interface

SBI, S-mode'daki işletim sistemi ile M-mode'daki firmware (OpenSBI) arasındaki standart arayüzdür. x86'daki BIOS/UEFI SMM çağrılarına benzer ama çok daha minimal ve açık bir spesifikasyona sahiptir.

OpenSBI

OpenSBI, RISC-V Foundation'ın referans SBI implementasyonudur. SiFive, Allwinner, StarFive ve diğer birçok RISC-V SoC üreticisi OpenSBI'yı platform firmware'i olarak kullanır. M-mode'da çalışır, donanıma özgü başlatma işlemlerini yapar ve S-mode kernel'e SBI hizmetleri sağlar.

SBI ecall mekanizması

# SBI çağrısı convention'ı:
# a7 = Extension ID (EID)
# a6 = Function ID (FID)
# a0-a5 = argümanlar
# Sonuç: a0 = error code, a1 = value

# Örnek: Console putchar (SBI v0.1 legacy)
li   a7, 0x01      # SBI_EXT_0_1_CONSOLE_PUTCHAR
li   a0, 0x41      # 'A' karakteri
ecall              # M-mode'a geç

# SBI Debug Console Write (v2.0 - EID: 0x4442434E)
li   a7, 0x4442434E   # DBCN extension
li   a6, 0x00         # FID: sbi_debug_console_write
li   a0, 1            # num_bytes
la   a1, msg          # base_addr_lo
li   a2, 0            # base_addr_hi
ecall

Önemli SBI Extension'lar

Linux kernel'deki arch/riscv/kernel/sbi.c bu extension'ları sbi_ecall() wrapper fonksiyonu üzerinden çağırır. CONFIG_RISCV_SBI etkin olduğunda kernel otomatik olarak mevcut SBI extension'larını probe eder.

03 Boot akışı

RISC-V'nin boot zinciri birden fazla aşamadan oluşur. Her aşama farklı bir privilege modunda çalışır ve bir sonraki aşamaya geçişi yönetir.

HiFive Unleashed özelinde tam akış

  Power-On Reset
       │
       ▼
  ┌─────────────────────────────────────┐
  │  ZSBL (Zero Stage Boot Loader)      │  M-mode, SPI Flash'tan
  │  ROM'da gömülü — MSEL pinlerine     │  boot kaynağını seçer
  │  göre önyükleme kaynağını seçer     │
  └─────────────────┬───────────────────┘
                    │
                    ▼
  ┌─────────────────────────────────────┐
  │  FSBL / OpenSBI (fw_dynamic.bin)    │  M-mode
  │  • SoC saatlerini başlatır          │
  │  • DDR eğitimi yapar                │
  │  • SBI hizmetlerini kur             │
  │  • U-Boot'u S-mode'da başlatır      │
  └─────────────────┬───────────────────┘
                    │  mret → S-mode
                    ▼
  ┌─────────────────────────────────────┐
  │  U-Boot (u-boot.bin)                │  S-mode
  │  • Ortam değişkenlerini yükle       │
  │  • Device Tree'yi hazırla           │
  │  • Kernel + initramfs'ı oku         │
  │  • booti komutu ile kernel'e geç    │
  └─────────────────┬───────────────────┘
                    │  sret → S-mode (kernel)
                    ▼
  ┌─────────────────────────────────────┐
  │  Linux Kernel                       │  S-mode
  │  • SBI üzerinden timer, IPI         │
  │  • Device Tree'den donanım keşfi    │
  │  • init/systemd başlatılır          │
  └─────────────────────────────────────┘
    

OpenSBI firmware modları

# OpenSBI derleme (HiFive Unleashed için):
git clone https://github.com/riscv-software-src/opensbi.git
cd opensbi
make PLATFORM=generic \
     CROSS_COMPILE=riscv64-linux-gnu- \
     FW_PAYLOAD_PATH=/path/to/u-boot.bin
# Çıktı: build/platform/generic/firmware/fw_payload.bin

04 QEMU virt makinesi üzerinde RISC-V Linux

QEMU'nun virt makinesi gerçek donanım olmadan RISC-V Linux geliştirmek için ideal ortamdır. OpenSBI otomatik olarak dahil edilir, U-Boot isteğe bağlıdır.

Gereksinimler

# Ubuntu/Debian
sudo apt install qemu-system-misc gcc-riscv64-linux-gnu \
                 binutils-riscv64-linux-gnu bison flex libssl-dev \
                 libncurses-dev bc

# QEMU versiyonu kontrolü (7.0+ önerilir):
qemu-system-riscv64 --version

Kernel derleme

git clone --depth=1 https://github.com/torvalds/linux.git
cd linux

# RISC-V defconfig
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- defconfig

# Derleme
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- -j$(nproc)

# Çıktı dosyaları:
# arch/riscv/boot/Image          — sıkıştırılmamış kernel
# arch/riscv/boot/Image.gz       — gzip sıkıştırılmış
# arch/riscv/boot/dts/sifive/   — SiFive DTB'leri

BusyBox initramfs

# BusyBox static derleme
wget https://busybox.net/downloads/busybox-1.36.1.tar.bz2
tar xf busybox-1.36.1.tar.bz2 && cd busybox-1.36.1
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- defconfig
# CONFIG_STATIC=y seçeneğini aktifleştir
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- \
     CONFIG_STATIC=y -j$(nproc)
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- install

# initramfs oluşturma
mkdir -p initramfs/{bin,sbin,etc,proc,sys,dev,tmp}
cp -a _install/* initramfs/
cat > initramfs/init << 'EOF'
#!/bin/sh
mount -t proc proc /proc
mount -t sysfs sysfs /sys
mount -t devtmpfs devtmpfs /dev
echo "RISC-V Linux hazir!"
exec /bin/sh
EOF
chmod +x initramfs/init

# cpio arşivi oluştur
cd initramfs
find . | cpio -o -H newc | gzip > ../initramfs.cpio.gz

QEMU ile başlatma

qemu-system-riscv64 \
  -machine virt \
  -cpu rv64 \
  -smp 4 \
  -m 1G \
  -kernel linux/arch/riscv/boot/Image \
  -initrd initramfs.cpio.gz \
  -append "root=/dev/ram rw console=ttyS0 earlycon" \
  -nographic \
  -device virtio-net-device,netdev=net0 \
  -netdev user,id=net0,hostfwd=tcp::2222-:22

# OpenSBI banner göründükten sonra Linux boot edilecek
# Çıkmak için: Ctrl+A, X

05 Toolchain ve build sistemi

RISC-V için birden fazla toolchain seçeneği bulunur. Hedef ortama (bare-metal, Linux glibc, musl) göre doğru toolchain'i seçmek kritiktir.

Toolchain türleri

Buildroot ile RISC-V

git clone https://github.com/buildroot/buildroot.git
cd buildroot

# QEMU için hazır defconfig
make qemu_riscv64_virt_defconfig

# Ya da SiFive Unmatched için:
make sifive_unleashed_defconfig

# Özelleştirme
make menuconfig
# Target options → Target Architecture: RISCV
# Target options → Target Architecture Variant: rv64
# Target options → Target ABI: lp64d
# Toolchain → Toolchain type: Buildroot toolchain
# System configuration → Init system: BusyBox

make -j$(nproc)
# output/images/ altında: fw_dynamic.bin, Image, rootfs.ext2

Yocto ile RISC-V (SiFive Unmatched)

git clone https://git.yoctoproject.org/poky
git clone https://github.com/riscv/meta-riscv

cd poky
source oe-init-build-env build-riscv

# conf/bblayers.conf içine ekle:
BBLAYERS += "/path/to/meta-riscv"

# conf/local.conf:
MACHINE = "sifive-unmatched"
DISTRO = "poky"
IMAGE_FSTYPES = "wic.gz"

# Build
bitbake core-image-minimal

06 Kernel konfigürasyonu

RISC-V Linux kernel konfigürasyonu, hedef donanımın extension'larına ve kullanım senaryosuna göre özelleştirilmelidir.

Kritik CONFIG seçenekleri

Minimal RISC-V kernel .config parçası

CONFIG_ARCH_RV64I=y
CONFIG_CMODEL_MEDANY=y
CONFIG_SMP=y
CONFIG_NR_CPUS=8
CONFIG_RISCV_SBI=y
CONFIG_RISCV_SBI_V01=y
CONFIG_MMU=y
CONFIG_PAGE_OFFSET=0xff60000000000000

# Extension desteği
CONFIG_RISCV_ISA_C=y
CONFIG_RISCV_ISA_A=y
CONFIG_FPU=y

# Platform sürücüler
CONFIG_SERIAL_8250=y
CONFIG_SERIAL_OF_PLATFORM=y
CONFIG_VIRTIO_PCI=y
CONFIG_VIRTIO_BLK=y
CONFIG_VIRTIO_NET=y

# Device Tree
CONFIG_OF=y
CONFIG_OF_EARLY_FLATTREE=y

DTS (Device Tree Source) yapısı

// RISC-V virt machine DTS parçası
/ {
    compatible = "riscv-virtio";
    #address-cells = <2>;
    #size-cells = <2>;

    cpus {
        #address-cells = <1>;
        #size-cells = <0>;
        cpu@0 {
            compatible = "riscv";
            device_type = "cpu";
            reg = <0>;
            riscv,isa = "rv64imafdcsu";
            mmu-type = "riscv,sv48";
        };
    };

    memory@80000000 {
        device_type = "memory";
        reg = <0x0 0x80000000 0x0 0x40000000>; /* 1 GB */
    };
};

07 Gerçek donanım platformları

RISC-V Linux çalıştıran gerçek silikon platformları artık yaygın hale gelmiştir. Her birinin farklı özellikleri ve olgunluk seviyeleri bulunmaktadır.

VisionFive 2 için U-Boot + Kernel

# U-Boot derlemek (JH7110):
git clone https://github.com/starfive-tech/u-boot.git -b JH7110_VisionFive2_devel
cd u-boot
make CROSS_COMPILE=riscv64-linux-gnu- starfive_visionfive2_defconfig
make CROSS_COMPILE=riscv64-linux-gnu- -j$(nproc)

# Upstream Linux (JH7110 mainline 6.6+):
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- \
     starfive_visionfive2_defconfig
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- -j$(nproc) \
     dtbs arch/riscv/boot/Image.gz

08 Pratik: Minimal RISC-V Linux sistemi

Bu bölümde OpenSBI + U-Boot + Linux kernel + BusyBox initramfs zincirini QEMU üzerinde sıfırdan kuracağız. Tüm adımlar tek bir host Linux sistemi üzerinde gerçekleştirilebilir.

Proje dizin yapısı

  riscv-lab/
  ├── opensbi/          # OpenSBI kaynak ve fw_dynamic.bin
  ├── u-boot/           # U-Boot kaynak ve u-boot.bin
  ├── linux/            # Kernel kaynak ve Image
  ├── busybox/          # BusyBox rootfs
  └── initramfs.cpio.gz # Paketlenmiş initramfs
    

Adım 1: OpenSBI derleme

git clone https://github.com/riscv-software-src/opensbi.git --depth=1
cd opensbi
make PLATFORM=generic CROSS_COMPILE=riscv64-linux-gnu- -j$(nproc)
# Çıktı: build/platform/generic/firmware/fw_dynamic.bin
ls -lh build/platform/generic/firmware/fw_dynamic.bin

Adım 2: U-Boot derleme

git clone https://github.com/u-boot/u-boot.git --depth=1
cd u-boot
make CROSS_COMPILE=riscv64-linux-gnu- qemu-riscv64_smode_defconfig
make CROSS_COMPILE=riscv64-linux-gnu- -j$(nproc)
# Çıktı: u-boot.bin

Adım 3: Kernel + initramfs derleme

# Kernel
git clone --depth=1 https://github.com/torvalds/linux.git
cd linux
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- defconfig
make ARCH=riscv CROSS_COMPILE=riscv64-linux-gnu- -j$(nproc)

# BusyBox initramfs (daha önce anlatıldı)
# initramfs.cpio.gz hazırla

Adım 4: QEMU çalıştırma

qemu-system-riscv64 \
  -machine virt \
  -cpu rv64 \
  -smp 4 \
  -m 2G \
  -bios opensbi/build/platform/generic/firmware/fw_dynamic.bin \
  -kernel u-boot/u-boot.bin \
  -nographic

# U-Boot prompt'unda kernel'i yükle:
# => booti 0x84000000 0x88000000 ${fdtaddr}

# Otomasyon için bootcmd:
qemu-system-riscv64 \
  -machine virt \
  -cpu rv64 \
  -smp 4 \
  -m 2G \
  -bios opensbi/build/platform/generic/firmware/fw_dynamic.bin \
  -kernel linux/arch/riscv/boot/Image \
  -initrd initramfs.cpio.gz \
  -append "root=/dev/ram rw console=ttyS0,115200 loglevel=8" \
  -nographic

Beklenen çıktı

OpenSBI v1.3
   ____                    _____ ____ _____
  / __ \                  / ____|  _ \_   _|
 | |  | |_ __   ___ _ __ | (___ | |_) || |
 | |  | | '_ \ / _ \ '_ \ \___ \|  _ < | |
 | |__| | |_) |  __/ | | |____) | |_) || |_
  \____/| .__/ \___|_| |_|_____/|____/_____|
        | |
        |_|
...
[    0.000000] Linux version 6.8.0 (riscv64)
[    0.000000] OF: fdt: Ignoring memory range...
[    0.500000] Run /init as init process
RISC-V Linux hazir!
/ #