Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ef878199 authored by Sandeep Patil's avatar Sandeep Patil Committed by Alistair Delva
Browse files

staging: ion: split system and system-contig heaps 



This will allows us to build and load them both as individual
kernel modules.

Bug: 133508579
Test: ion-unit-tests

Change-Id: I8bdada5531fbf148e4d097e94e406a232874913a
Signed-off-by: default avatarSandeep Patil <sspatil@google.com>
parent 91d0bbda

arch/arm64/configs/gki_defconfig

+2 −0
Original line number Diff line number Diff line
@@ -349,6 +349,8 @@ CONFIG_STAGING=y 
CONFIG_ASHMEM=y

CONFIG_ANDROID_VSOC=y

CONFIG_ION=y

CONFIG_ION_SYSTEM_HEAP=y

CONFIG_ION_SYSTEM_CONTIG_HEAP=y

CONFIG_COMMON_CLK_SCPI=y

CONFIG_HWSPINLOCK=y

CONFIG_MAILBOX=y

arch/x86/configs/gki_defconfig

+2 −0
Original line number Diff line number Diff line
@@ -289,6 +289,8 @@ CONFIG_VIRTIO_MMIO_CMDLINE_DEVICES=y 
CONFIG_STAGING=y

CONFIG_ASHMEM=y

CONFIG_ION=y

CONFIG_ION_SYSTEM_HEAP=y

CONFIG_ION_SYSTEM_CONTIG_HEAP=y

CONFIG_PM_DEVFREQ=y

CONFIG_ANDROID=y

CONFIG_ANDROID_BINDER_IPC=y

drivers/staging/android/ion/heaps/Kconfig

+8 −0
Original line number Diff line number Diff line
@@ -6,6 +6,14 @@ config ION_SYSTEM_HEAP 
	  Choose this option to enable the Ion system heap. The system heap

	  is backed by pages from the buddy allocator. If in doubt, say Y.



config ION_SYSTEM_CONTIG_HEAP

	bool "Ion system contig heap"

	depends on ION

	help

	  Choose this option to enable Ion system contig heap. The system contig heap

	  is backed by the pages from buddy allocator that are guaranteed to be physically

	  contiguous. If in doubt, say Y.



config ION_CMA_HEAP

	bool "Ion CMA heap support"

	depends on ION && DMA_CMA

drivers/staging/android/ion/heaps/Makefile

+1 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

obj-$(CONFIG_ION_SYSTEM_HEAP) += ion_system_heap.o ion_page_pool.o

obj-$(CONFIG_ION_SYSTEM_CONTIG_HEAP) += ion_system_contig_heap.o

obj-$(CONFIG_ION_CMA_HEAP) += ion_cma_heap.o

drivers/staging/android/ion/heaps/ion_system_contig_heap.c

0 → 100644
+111 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * ION Memory Allocator system contig heap exporter

 *

 * Copyright (C) 2019 Google, Inc.

 */



#include <asm/page.h>

#include <linux/dma-mapping.h>

#include <linux/err.h>

#include <linux/highmem.h>

#include <linux/ion.h>

#include <linux/mm.h>

#include <linux/scatterlist.h>

#include <linux/slab.h>



static int ion_system_contig_heap_allocate(struct ion_heap *heap,

					   struct ion_buffer *buffer,

					   unsigned long len,

					   unsigned long flags)

{

	int order = get_order(len);

	struct page *page;

	struct sg_table *table;

	unsigned long i;

	int ret;



	page = alloc_pages(GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN, order);

	if (!page)

		return -ENOMEM;



	split_page(page, order);



	len = PAGE_ALIGN(len);

	for (i = len >> PAGE_SHIFT; i < (1 << order); i++)

		__free_page(page + i);



	table = kmalloc(sizeof(*table), GFP_KERNEL);

	if (!table) {

		ret = -ENOMEM;

		goto free_pages;

	}



	ret = sg_alloc_table(table, 1, GFP_KERNEL);

	if (ret)

		goto free_table;



	sg_set_page(table->sgl, page, len, 0);



	buffer->sg_table = table;



	return 0;



free_table:

	kfree(table);

free_pages:

	for (i = 0; i < len >> PAGE_SHIFT; i++)

		__free_page(page + i);



	return ret;

}



static void ion_system_contig_heap_free(struct ion_buffer *buffer)

{

	struct sg_table *table = buffer->sg_table;

	struct page *page = sg_page(table->sgl);

	unsigned long pages = PAGE_ALIGN(buffer->size) >> PAGE_SHIFT;

	unsigned long i;



	for (i = 0; i < pages; i++)

		__free_page(page + i);

	sg_free_table(table);

	kfree(table);

}



static struct ion_heap_ops kmalloc_ops = {

	.allocate = ion_system_contig_heap_allocate,

	.free = ion_system_contig_heap_free,

	.map_kernel = ion_heap_map_kernel,

	.unmap_kernel = ion_heap_unmap_kernel,

	.map_user = ion_heap_map_user,

};



static struct ion_heap *__ion_system_contig_heap_create(void)

{

	struct ion_heap *heap;



	heap = kzalloc(sizeof(*heap), GFP_KERNEL);

	if (!heap)

		return ERR_PTR(-ENOMEM);

	heap->ops = &kmalloc_ops;

	heap->type = ION_HEAP_TYPE_SYSTEM_CONTIG;

	heap->name = "ion_system_contig_heap";



	return heap;

}



static int ion_system_contig_heap_create(void)

{

	struct ion_heap *heap;



	heap = __ion_system_contig_heap_create();

	if (IS_ERR(heap))

		return PTR_ERR(heap);



	ion_device_add_heap(heap);



	return 0;

}

device_initcall(ion_system_contig_heap_create);