Linux Kernel and 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 device found):

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);  // for bus master
    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);
    
    // Load firmware
    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 IOCTLs
    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 strategies:

1. printk: pr_info, pr_warn, pr_err. Visible via dmesg.
2. sysfs: /sys/class/sidra/sidra0/temperature, /error_count.
3. debugfs: /sys/kernel/debug/sidra/. Detailed stats.
4. kgdb: kernel debugger. Tricky.
5. ftrace: function trace. Performance profiling.

Race conditions:

The kernel is preemptive. Critical sections need spinlocks or mutexes:

mutex_lock(&sdev->cmd_lock);
// critical section
mutex_unlock(&sdev->cmd_lock);

Power management:

Suspend/resume callbacks:

static int aether_suspend(struct pci_dev *pdev, pm_message_t state) {
    // Put chip to sleep, save state
    return 0;
}

static int aether_resume(struct pci_dev *pdev) {
    // Wake chip, restore state
    return 0;
}

Multi-instance:

If multiple SIDRA chips: /dev/sidra0, /dev/sidra1, … separate major/minor. The driver picks by minor number.

Upstream submission:

To be accepted into the Linux kernel:

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

SIDRA upstream target: post-2027 Y1 production. ASELSAN/university Linux community contribution.

Kernel ABI:

aether-driver’s IOCTL interface is stable. Versioning:

• AETHER_API_V1 (Y1): 33 IOCTLs.
• AETHER_API_V2 (Y3): + 10 IOCTLs (new features).

User-space apps support both (compile-time check).