rk3188--13.android 内核下ion分配内存

一. 内核启动时保留内存
start_kernel
    --> setup_arch
        -->arm_memblock_init
            --> rk30_reserve
在内核启动时会保留一部分内存
在arch/arm/mach-rk3188/board-rk3188-ds1006h.c中

static void __init rk30_reserve(void)
{
    //保存在变量 rk30_ion_pdata.heaps[0].base 中
    rk30_ion_pdata.heaps[0].base = board_mem_reserve_add("ion", ION_RESERVE_SIZE);
}

bank.start=0x60000000, size=0x36800000
reserved_base_end就是内存的结束地址: 0x6000000+0x36800000=0x96800000

phys_addr_t __init board_mem_reserve_add(char *name, size_t size)
{
    phys_addr_t base = 0;
    if(reserved_base_end == 0)
        reserved_base_end = meminfo.bank[0].start + meminfo.bank[0].size;
    reserved_size += size;
    base = reserved_base_end - reserved_size;

    return base;
}

分配内存之后base=内存结束地址-80M=0x96800000-0x5000000=0x91800000
memory reserve: Memory(base:0x91800000 size:80M) reserved for

---

二. ION驱动的初始化
2.1 platform_device
在arch/arm/mach-rk3188/board-rk3188-ds1006h.c中

static struct ion_platform_data rk30_ion_pdata = {
    .nr = 1,
    .heaps = {
        {
            .type = ION_HEAP_TYPE_CARVEOUT,  //reserve memory:这是在保留内存块中分配内存
            .id = ION_NOR_HEAP_ID,
            .name = "norheap",
            .size = ION_RESERVE_SIZE,
        }
    },
};

static struct platform_device device_ion = {
    .name = "ion-rockchip",
    .id = 0,
    .dev = {
        .platform_data = &rk30_ion_pdata,
    },
};

2.2 platform_driver
cong@ubuntu:/rk/rk3188/kernel/drivers/gpu$ tree
├── ion
│   ├── ion.c
│   ├── ion_carveout_heap.c
│   ├── ion_heap.c
│   ├── ion_priv.h
│   ├── ion_system_heap.c
│   ├── ion_system_mapper.c
│   └── rockchip
│       └── rockchip_ion.c
└── Makefile
module_init(ion_init);
    --> ion_init

static struct platform_driver ion_driver = {
    .probe = rockchip_ion_probe,
    .remove = rockchip_ion_remove,
    .driver = { .name = "ion-rockchip" }
};

static int __init ion_init(void)
{
    return platform_driver_register(&ion_driver);
}

module_init(ion_init);
    --> ion_init
        --> rockchip_ion_probe

static int rockchip_ion_probe(struct platform_device *pdev)
{
    struct ion_device *idev;
    struct ion_platform_data *pdata = pdev->dev.platform_data;

    num_heaps = pdata->nr;    //num_heaps =1
    heaps = kzalloc(sizeof(struct ion_heap *) * pdata->nr, GFP_KERNEL);

    idev = ion_device_create(rockchip_custom_ioctl);

    for (i = 0; i < num_heaps; i++) {
        struct ion_platform_heap *heap_data = &pdata->heaps[i];
        heaps[i] = ion_heap_create(heap_data);
        ion_device_add_heap(idev, heaps[i]);
    }
    platform_set_drvdata(pdev, idev);
    return 0;
}

rockchip_ion_probe
    --> ion_device_create
在drivers/gpu/ion/ion.c中

struct ion_device *ion_device_create(long (*custom_ioctl)(struct ion_client *client, unsigned int cmd, unsigned long arg))
{
    struct ion_device *idev;
    idev = kzalloc(sizeof(struct ion_device), GFP_KERNEL);
    idev->dev.minor = MISC_DYNAMIC_MINOR;
    idev->dev.name = "ion";
    idev->dev.fops = &ion_fops;
    idev->dev.parent = NULL;
    ret = misc_register(&idev->dev);

    idev->debug_root = debugfs_create_dir("ion", NULL);

    idev->custom_ioctl = custom_ioctl;
    idev->buffers = RB_ROOT;
    mutex_init(&idev->lock);
    idev->heaps = RB_ROOT;
    idev->user_clients = RB_ROOT;
    idev->kernel_clients = RB_ROOT;
    debugfs_create_file("leak", 0664, idev->debug_root, idev, &debug_leak_fops);
    return idev;
}

rockchip_ion_probe
    --> ion_heap_create

struct ion_heap *ion_heap_create(struct ion_platform_heap *heap_data)
{
    struct ion_heap *heap = NULL;

    switch (heap_data->type) {
    case ION_HEAP_TYPE_SYSTEM_CONTIG:  //通过kmalloc分配内存
        heap = ion_system_contig_heap_create(heap_data);
        break;
    case ION_HEAP_TYPE_SYSTEM:    //通过vmalloc分配内存
        heap = ion_system_heap_create(heap_data);
        break;
    case ION_HEAP_TYPE_CARVEOUT:    //在保留内存块中（reserve memory）分配内存
        heap = ion_carveout_heap_create(heap_data);
        break;
    default:
        pr_err("%s: Invalid heap type %d\n", __func__, heap_data->type);
        return ERR_PTR(-EINVAL);
    }
    heap->name = heap_data->name;
    heap->id = heap_data->id;
    return heap;
}

 rockchip_ion_probe
    --> ion_heap_create
        --> ion_carveout_heap_create  
在drivers/gpu/ion/ion_heap.c中

struct ion_heap *ion_carveout_heap_create(struct ion_platform_heap *heap_data)
{
    struct ion_carveout_heap *carveout_heap;

    carveout_heap = kzalloc(sizeof(struct ion_carveout_heap), GFP_KERNEL);

    carveout_heap->pool = gen_pool_create(12, -1);
    carveout_heap->base = heap_data->base;               //系统保留的物理地址base=0x91800000
    // 向内存池中加入内存块，起始地址base=0x918000000，size=0x50000000=80M
    gen_pool_add(carveout_heap->pool, carveout_heap->base, heap_data->size, -1);
    carveout_heap->heap.ops = &carveout_heap_ops;
    carveout_heap->heap.type = ION_HEAP_TYPE_CARVEOUT;
    carveout_heap->heap.allocated_size = 0;
    carveout_heap->heap.max_allocated = 0;
    carveout_heap->heap.total_size = heap_data->size;    // size=0x5000000=80M
    //内存的映射位图: 每个bit代表1个PAGE
    carveout_heap->bit_nr = heap_data->size/(PAGE_SIZE * sizeof(unsigned long) * 8);
    carveout_heap->bits =  (unsigned long *)kzalloc(carveout_heap->bit_nr * sizeof(unsigned long), GFP_KERNEL);

    return &carveout_heap->heap;
}

rockchip_ion_probe
    --> ion_device_add_heap

void ion_device_add_heap(struct ion_device *dev, struct ion_heap *heap)
{
    struct rb_node **p = &dev->heaps.rb_node;
    struct rb_node *parent = NULL;
    struct ion_heap *entry;

    heap->dev = dev;
    mutex_lock(&dev->lock);
    while (*p) {
        parent = *p;
        entry = rb_entry(parent, struct ion_heap, node);

        if (heap->id < entry->id) {
            p = &(*p)->rb_left;
        } else if (heap->id > entry->id ) {
            p = &(*p)->rb_right;
        } else {
            pr_err("%s: can not insert multiple heaps with id %d\n", __func__, heap->id);
            goto end;
        }
    }

    rb_link_node(&heap->node, parent, p);
    rb_insert_color(&heap->node, &dev->heaps);
    debugfs_create_file(heap->name, 0664, dev->debug_root, heap, &debug_heap_fops);
end:
    mutex_unlock(&dev->lock);
}

三. ION分配内存的过程
drivers/gpu/ion/ion.c --> ion_ioctl   //cmd=0xc0104900 接收到命令:ION_IOC_ALLOC
    --> ion_alloc
    --> ion_carveout_heap_allocate
    --> drivers/gpu/ion/ion_carveout_heap.c  调用 ion_carveout_allocate[47]:

static int ion_carveout_heap_allocate(struct ion_heap *heap,
       struct ion_buffer *buffer, unsigned long size, unsigned long align,       unsigned long flags)
{
    buffer->priv_phys = ion_carveout_allocate(heap, size, align); //buffer->priv_phy=0x91a00000是物理地址
    return buffer->priv_phys == ION_CARVEOUT_ALLOCATE_FAIL ? -ENOMEM : 0;
}

ion_carveout_heap_allocate
    --> ion_carveout_allocate
在drivers/gpu/ion/ion_carverout_heap.c中

ion_phys_addr_t ion_carveout_allocate(struct ion_heap *heap, unsigned long size, unsigned long align)
{
    struct ion_carveout_heap *carveout_heap = container_of(heap, struct ion_carveout_heap, heap);
    unsigned long offset = gen_pool_alloc(carveout_heap->pool, size);   //offset=0x91a00000,是物理地址

    heap->allocated_size += size;     //统计己分配的大小
    //防止越界
    if((offset + size - carveout_heap->base) > heap->max_allocated)
        heap->max_allocated = offset + size - carveout_heap->base;
    //填充位图
    bitmap_set(carveout_heap->bits, (offset - carveout_heap->base)/PAGE_SIZE , size/PAGE_SIZE);
    return offset;
}

原理很简单:
    就是在位图中查找适合的大小,然后把位图所代表的地址返回 (怎么有点表达不清楚了??? 反正就这个意思,呵呵)
ion_carveout_heap_allocate
    --> ion_carveout_allocate
        --> gen_pool_alloc
在lib/genalloc.c中

unsigned long gen_pool_alloc(struct gen_pool *pool, size_t size)
{
    struct list_head *_chunk;
    struct gen_pool_chunk *chunk;
    unsigned long addr, flags;
    int order = pool->min_alloc_order;
    int nbits, start_bit, end_bit;

    if (size == 0)
        return 0;

    nbits = (size + (1UL << order) - 1) >> order;  //由字节转成块,转成位图所代表的大小

    read_lock(&pool->lock);
    list_for_each(_chunk, &pool->chunks) {
        chunk = list_entry(_chunk, struct gen_pool_chunk, next_chunk);

        end_bit = (chunk->end_addr - chunk->start_addr) >> order;

        spin_lock_irqsave(&chunk->lock, flags);
        //在这个内存位图中查找足够大的内存
        start_bit = bitmap_find_next_zero_area(chunk->bits, end_bit, 0, nbits, 0);
        if (start_bit >= end_bit) {
            spin_unlock_irqrestore(&chunk->lock, flags);
            continue;
        }
        //由位图映射到实际的地址
        addr = chunk->start_addr + ((unsigned long)start_bit << order);
        //填充位图,说明这块内存地方己分配
        bitmap_set(chunk->bits, start_bit, nbits);
        spin_unlock_irqrestore(&chunk->lock, flags);
        read_unlock(&pool->lock);
        return addr;   //返回地址
    }
    read_unlock(&pool->lock);
    return 0;
}
EXPORT_SYMBOL(gen_pool_alloc);