Linux Kernel ve aether-driver

Module init/exit:

static int __init aether_init(void) {
    int ret = pci_register_driver(&aether_pci_driver);
    if (ret) return ret;
    
    pr_info("aether-driver loaded, version %s\n", AETHER_VERSION);
    return 0;
}

static void __exit aether_exit(void) {
    pci_unregister_driver(&aether_pci_driver);
    pr_info("aether-driver unloaded\n");
}

module_init(aether_init);
module_exit(aether_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("SIDRA Team");

Probe (PCIe cihaz bulundu):

static int aether_probe(struct pci_dev *pdev, const struct pci_device_id *id) {
    struct sidra_dev *sdev = kzalloc(sizeof(*sdev), GFP_KERNEL);
    pci_set_drvdata(pdev, sdev);
    
    pci_enable_device(pdev);
    pci_set_master(pdev);  // bus master için
    pci_request_regions(pdev, "sidra");
    
    // BAR0 = control registers
    sdev->bar0 = pci_iomap(pdev, 0, 0);
    
    // BAR1 = DMA area
    sdev->bar1 = pci_iomap(pdev, 1, 0);
    
    // IRQ
    pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
    request_irq(pci_irq_vector(pdev, 0), aether_irq_handler,
                0, "sidra", sdev);
    
    // /dev/sidra0
    create_char_device(sdev);
    
    // Firmware yükle
    aether_load_firmware(sdev);
    
    return 0;
}

IOCTL handler:

static long aether_ioctl(struct file *f, unsigned int cmd, unsigned long arg) {
    struct sidra_dev *sdev = f->private_data;
    
    switch (cmd) {
    case SIDRA_IOCTL_VERSION: {
        u32 ver = readl(sdev->bar0 + REG_VERSION);
        return copy_to_user((void __user *)arg, &ver, sizeof(ver));
    }
    case SIDRA_IOCTL_LOAD_MODEL: {
        struct model_data m;
        copy_from_user(&m, (void __user *)arg, sizeof(m));
        return aether_load_model(sdev, &m);
    }
    case SIDRA_IOCTL_INFER: {
        struct inference_req req;
        copy_from_user(&req, (void __user *)arg, sizeof(req));
        return aether_run_inference(sdev, &req);
    }
    // ... 33 IOCTL komut
    default:
        return -ENOTTY;
    }
}

Interrupt handler:

static irqreturn_t aether_irq_handler(int irq, void *data) {
    struct sidra_dev *sdev = data;
    u32 status = readl(sdev->bar0 + REG_INT_STATUS);
    
    if (status & INT_INFERENCE_DONE) {
        wake_up(&sdev->infer_wait);
        writel(INT_INFERENCE_DONE, sdev->bar0 + REG_INT_CLEAR);
    }
    
    if (status & INT_ERROR) {
        u32 err = readl(sdev->bar0 + REG_ERROR_CODE);
        pr_warn("SIDRA error: 0x%x\n", err);
    }
    
    return IRQ_HANDLED;
}

Debug stratejileri:

1. printk: pr_info, pr_warn, pr_err. dmesg ile görünür.
2. sysfs: /sys/class/sidra/sidra0/temperature, /error_count.
3. debugfs: /sys/kernel/debug/sidra/. Detaylı stats.
4. kgdb: kernel debugger. Karmaşık.
5. ftrace: function trace. Performance profiling.

Race condition’lar:

Kernel preemptive. Driver kritik bölge için spinlock veya mutex:

mutex_lock(&sdev->cmd_lock);
// kritik bölge
mutex_unlock(&sdev->cmd_lock);

Power management:

Suspend/resume callback’ler:

static int aether_suspend(struct pci_dev *pdev, pm_message_t state) {
    // Çipi sleep moda al, state sakla
    return 0;
}

static int aether_resume(struct pci_dev *pdev) {
    // Çipi uyandır, state geri yükle
    return 0;
}

Multi-instance:

Birden fazla SIDRA çipi varsa /dev/sidra0, /dev/sidra1, … her biri ayrı major/minor. Driver minor numarayla cihazı seçer.

Upstream’e gönderim:

Linux kernel’a kabul edilmek için:

1. Coding style (kernel checkpatch.pl).
2. Documentation/.
3. SubmittingPatches kuralları.
4. LKML (Linux Kernel Mailing List) review.
5. Maintainer ile review.

SIDRA upstream hedefi: 2027 Y1 production sonrası. ASELSAN/üniversite Linux community katkısı.

Kernel ABI:

aether-driver’in IOCTL interface stabil. Versiyonlama:

• AETHER_API_V1 (Y1): 33 IOCTL.
• AETHER_API_V2 (Y3): + 10 IOCTL (yeni features).

User-space app her ikisini destekler (compile-time check).