linux dma api

struct dma_chan *chan = dma_request_channel(mask, filter_fn, filter_param);
if (!chan) {
    printk(KERN_ERR "Failed to request DMA channel\n");
    return -ENODEV;
}

dma_addr_t dma_handle;
void *virt_addr = dma_alloc_coherent(chan->device->dev, size, &dma_handle, GFP_KERNEL);
if (!virt_addr) {
    printk(KERN_ERR "Failed to allocate DMA buffer\n");
    dma_release_channel(chan);
    return -ENOMEM;
}

irqreturn_t dma_isr(int irq, void *dev_id) {
    struct dma_device *dev = dev_id;
    // 处理中断逻辑
    dma_ack_interrupt(dev);
    return IRQ_HANDLED;
}

int dma_setup_isr(struct dma_device *dev, int irq) {
    return request_irq(irq, dma_isr, IRQF_SHARED, dev_name(&dev->dev), dev);
}

#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>

struct dma_chan *chan;
dma_addr_t dma_src, dma_dst;
void *src, *dst;

int setup_dma(void) {
    chan = dma_request_channel(DMA_MEMCPY_MASK, NULL, NULL);
    if (!chan) {
        printk(KERN_ERR "Failed to request DMA channel\n");
        return -ENODEV;
    }

    src = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    dst = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    if (!src || !dst) {
        printk(KERN_ERR "Failed to allocate memory\n");
        dma_release_channel(chan);
        return -ENOMEM;
    }

    dma_src = dma_map_single(chan->device->dev, src, BUFFER_SIZE, DMA_TO_DEVICE);
    dma_dst = dma_map_single(chan->device->dev, dst, BUFFER_SIZE, DMA_FROM_DEVICE);

    struct dma_async_tx_descriptor *desc = dmaengine_prep_dma_memcpy(chan, dma_dst, dma_src, BUFFER_SIZE, DMA_CTRL_ACK | DMA_PREP_INTERRUPT);
    if (!desc) {
        printk(KERN_ERR "Failed to prepare DMA memcpy\n");
        dma_unmap_single(chan->device->dev, dma_src, BUFFER_SIZE, DMA_TO_DEVICE);
        dma_unmap_single(chan->device->dev, dma_dst, BUFFER_SIZE, DMA_FROM_DEVICE);
        kfree(src);
        kfree(dst);
        dma_release_channel(chan);
        return -EFAULT;
    }

    dmaengine_submit(desc);
    dma_async_issue_pending(chan);

    return 0;
}