device的私有memory

一般调用of_reserved_mem_device_init来将reserved memory分配给特定的device.

例如drivers/gpu/drm/arm/malidp_drv.c, line 313

static inline int of_reserved_mem_device_init(struct device *dev)

{

    return of_reserved_mem_device_init_by_idx(dev, dev->of_node, 0);

}

这个函数直接转掉of_reserved_mem_device_init_by_idx

int of_reserved_mem_device_init_by_idx(struct device *dev,

                       struct device_node *np, int idx)

{

    struct rmem_assigned_device *rd;

    struct device_node *target;

    struct reserved_mem *rmem;

    int ret;

    if (!np || !dev)

        return -EINVAL;

    target = of_parse_phandle(np, "memory-region", idx);

    if (!target)

        return -ENODEV;

    rmem = __find_rmem(target);

    of_node_put(target);

    if (!rmem || !rmem->ops || !rmem->ops->device_init)

        return -EINVAL;

    rd = kmalloc(sizeof(struct rmem_assigned_device), GFP_KERNEL);

    if (!rd)

        return -ENOMEM;

    ret = rmem->ops->device_init(rmem, dev);

    if (ret == 0) {

        rd->dev = dev;

        rd->rmem = rmem;

        mutex_lock(&of_rmem_assigned_device_mutex);

        list_add(&rd->list, &of_rmem_assigned_device_list);

        mutex_unlock(&of_rmem_assigned_device_mutex);

        dev_info(dev, "assigned reserved memory node %s\n", rmem->name);

    } else {

        kfree(rd);

    }

    return ret;

}

在of_reserved_mem_device_init_by_idx 中主要通过在dts中parse memory-region来决定给device哪个reserved memory

首先通过__find_rmem 找到这个reserved memory，然后申请一个rmem_assigned_device *rd 结构

通过调用rmem->ops->device_init(rmem, dev)来将reserved memory 分配给device

而这里的ops其实是下面这个

static const struct reserved_mem_ops rmem_dma_ops = {

    .device_init    = rmem_dma_device_init,

    .device_release    = rmem_dma_device_release,

};

因此调用rmem_dma_device_init->dma_assign_coherent_memory

static int dma_assign_coherent_memory(struct device *dev,

                      struct dma_coherent_mem *mem)

{

    if (dev->dma_mem)

        return -EBUSY;

    dev->dma_mem = mem;

    /* FIXME: this routine just ignores DMA_MEMORY_INCLUDES_CHILDREN */

    return 0;

}

来将memory 赋值dev->dma_mem

那这种私有的memory 要具体怎么使用呢？

因此我们前面讲dma_alloc_coherent->dma_alloc_attrs->dma_alloc_from_coherent

int dma_alloc_from_coherent(struct device *dev, ssize_t size,

                       dma_addr_t *dma_handle, void **ret)

{

    struct dma_coherent_mem *mem;

    int order = get_order(size);

    unsigned long flags;

    int pageno;

    int dma_memory_map;

    if (!dev)

        return 0;

    mem = dev->dma_mem;

    if (!mem)

        return 0;

    *ret = NULL;

    spin_lock_irqsave(&mem->spinlock, flags);

    if (unlikely(size > (mem->size << PAGE_SHIFT)))

        goto err;

    pageno = bitmap_find_free_region(mem->bitmap, mem->size, order);

    if (unlikely(pageno < 0))

        goto err;

    /*

     * Memory was found in the per-device area.

     */

    *dma_handle = mem->device_base + (pageno << PAGE_SHIFT);

    *ret = mem->virt_base + (pageno << PAGE_SHIFT);

    dma_memory_map = (mem->flags & DMA_MEMORY_MAP);

    spin_unlock_irqrestore(&mem->spinlock, flags);

    if (dma_memory_map)

        memset(*ret, 0, size);

    else

        memset_io(*ret, 0, size);

    return 1;

err:

    spin_unlock_irqrestore(&mem->spinlock, flags);

    /*

     * In the case where the allocation can not be satisfied from the

     * per-device area, try to fall back to generic memory if the

     * constraints allow it.

     */

    return mem->flags & DMA_MEMORY_EXCLUSIVE;

}

这个函数就会使用这个device 私有的memory