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

Commit 1dbd9a27 authored by Liam Mark's avatar Liam Mark
Browse files

ion: Revert upstream changes for now 



Upstream has made changes to the ion framework which are not compatible
with qcom-added features. Revert these temporarily until a proper
integration can be done.

Revert to:
commit d0164adc ("mm, page_alloc: distinguish between being unable to
sleep, unwilling to sleep and avoiding waking kswapd")

Also disable ION so that a snapshot can be properly applied on
top of it.

Change-Id: I81747f93dd3e4c408aa01a060b7d9b115158be2b
Signed-off-by: default avatarLiam Mark <lmark@codeaurora.org>
parent 12a5a50e

arch/arm64/configs/sdm855-perf_defconfig

+0 −1
Original line number Diff line number Diff line
@@ -296,7 +296,6 @@ CONFIG_DMADEVICES=y 
CONFIG_UIO=y

CONFIG_STAGING=y

CONFIG_ASHMEM=y

CONFIG_ION=y

CONFIG_ARM_SMMU=y

CONFIG_QCOM_SCM=y

CONFIG_EXTCON=y

arch/arm64/configs/sdm855_defconfig

+0 −1
Original line number Diff line number Diff line
@@ -302,7 +302,6 @@ CONFIG_DMADEVICES=y 
CONFIG_UIO=y

CONFIG_STAGING=y

CONFIG_ASHMEM=y

CONFIG_ION=y

CONFIG_ARM_SMMU=y

CONFIG_QCOM_SCM=y

CONFIG_EXTCON=y

drivers/staging/android/ion/Kconfig

+15 −24
Original line number Diff line number Diff line
@@ -10,35 +10,26 @@ menuconfig ION 
	  If you're not using Android its probably safe to

	  say N here.



config ION_SYSTEM_HEAP

	bool "Ion system heap"

config ION_TEST

	tristate "Ion Test Device"

	depends on ION

	help

	  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.

	  Choose this option to create a device that can be used to test the

	  kernel and device side ION functions.



config ION_CARVEOUT_HEAP

	bool "Ion carveout heap support"

config ION_DUMMY

	bool "Dummy Ion driver"

	depends on ION

	help

	  Choose this option to enable carveout heaps with Ion. Carveout heaps

	  are backed by memory reserved from the system. Allocation times are

	  typically faster at the cost of memory not being used. Unless you

	  know your system has these regions, you should say N here.

	  Provides a dummy ION driver that registers the

	  /dev/ion device and some basic heaps. This can

	  be used for testing the ION infrastructure if

	  one doesn't have access to hardware drivers that

	  use ION.



config ION_CHUNK_HEAP

	bool "Ion chunk heap support"

	depends on ION

config ION_TEGRA

	tristate "Ion for Tegra"

	depends on ARCH_TEGRA && ION

	help

          Choose this option to enable chunk heaps with Ion. This heap is

	  similar in function the carveout heap but memory is broken down

	  into smaller chunk sizes, typically corresponding to a TLB size.

	  Unless you know your system has these regions, you should say N here.

	  Choose this option if you wish to use ion on an nVidia Tegra.

config ION_CMA_HEAP

	bool "Ion CMA heap support"

	depends on ION && CMA

	help

	  Choose this option to enable CMA heaps with Ion. This heap is backed

	  by the Contiguous Memory Allocator (CMA). If your system has these

	  regions, you should say Y here.

drivers/staging/android/ion/Makefile

+10 −5
Original line number Diff line number Diff line 
obj-$(CONFIG_ION) +=	ion.o ion-ioctl.o ion_heap.o

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

obj-$(CONFIG_ION_CARVEOUT_HEAP) += ion_carveout_heap.o

obj-$(CONFIG_ION_CHUNK_HEAP) += ion_chunk_heap.o

obj-$(CONFIG_ION_CMA_HEAP) += ion_cma_heap.o
 
obj-$(CONFIG_ION) +=	ion.o ion_heap.o ion_page_pool.o ion_system_heap.o \

			ion_carveout_heap.o ion_chunk_heap.o ion_cma_heap.o

obj-$(CONFIG_ION_TEST) += ion_test.o

ifdef CONFIG_COMPAT

obj-$(CONFIG_ION) += compat_ion.o

endif



obj-$(CONFIG_ION_DUMMY) += ion_dummy_driver.o

obj-$(CONFIG_ION_TEGRA) += tegra/

drivers/staging/android/ion/compat_ion.c

0 → 100644
+195 −0
Original line number Diff line number Diff line 
/*

 * drivers/staging/android/ion/compat_ion.c

 *

 * Copyright (C) 2013 Google, Inc.

 *

 * This software is licensed under the terms of the GNU General Public

 * License version 2, as published by the Free Software Foundation, and

 * may be copied, distributed, and modified under those terms.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */



#include <linux/compat.h>

#include <linux/fs.h>

#include <linux/uaccess.h>



#include "ion.h"

#include "compat_ion.h"



/* See drivers/staging/android/uapi/ion.h for the definition of these structs */

struct compat_ion_allocation_data {

	compat_size_t len;

	compat_size_t align;

	compat_uint_t heap_id_mask;

	compat_uint_t flags;

	compat_int_t handle;

};



struct compat_ion_custom_data {

	compat_uint_t cmd;

	compat_ulong_t arg;

};



struct compat_ion_handle_data {

	compat_int_t handle;

};



#define COMPAT_ION_IOC_ALLOC	_IOWR(ION_IOC_MAGIC, 0, \

				      struct compat_ion_allocation_data)

#define COMPAT_ION_IOC_FREE	_IOWR(ION_IOC_MAGIC, 1, \

				      struct compat_ion_handle_data)

#define COMPAT_ION_IOC_CUSTOM	_IOWR(ION_IOC_MAGIC, 6, \

				      struct compat_ion_custom_data)



static int compat_get_ion_allocation_data(

			struct compat_ion_allocation_data __user *data32,

			struct ion_allocation_data __user *data)

{

	compat_size_t s;

	compat_uint_t u;

	compat_int_t i;

	int err;



	err = get_user(s, &data32->len);

	err |= put_user(s, &data->len);

	err |= get_user(s, &data32->align);

	err |= put_user(s, &data->align);

	err |= get_user(u, &data32->heap_id_mask);

	err |= put_user(u, &data->heap_id_mask);

	err |= get_user(u, &data32->flags);

	err |= put_user(u, &data->flags);

	err |= get_user(i, &data32->handle);

	err |= put_user(i, &data->handle);



	return err;

}



static int compat_get_ion_handle_data(

			struct compat_ion_handle_data __user *data32,

			struct ion_handle_data __user *data)

{

	compat_int_t i;

	int err;



	err = get_user(i, &data32->handle);

	err |= put_user(i, &data->handle);



	return err;

}



static int compat_put_ion_allocation_data(

			struct compat_ion_allocation_data __user *data32,

			struct ion_allocation_data __user *data)

{

	compat_size_t s;

	compat_uint_t u;

	compat_int_t i;

	int err;



	err = get_user(s, &data->len);

	err |= put_user(s, &data32->len);

	err |= get_user(s, &data->align);

	err |= put_user(s, &data32->align);

	err |= get_user(u, &data->heap_id_mask);

	err |= put_user(u, &data32->heap_id_mask);

	err |= get_user(u, &data->flags);

	err |= put_user(u, &data32->flags);

	err |= get_user(i, &data->handle);

	err |= put_user(i, &data32->handle);



	return err;

}



static int compat_get_ion_custom_data(

			struct compat_ion_custom_data __user *data32,

			struct ion_custom_data __user *data)

{

	compat_uint_t cmd;

	compat_ulong_t arg;

	int err;



	err = get_user(cmd, &data32->cmd);

	err |= put_user(cmd, &data->cmd);

	err |= get_user(arg, &data32->arg);

	err |= put_user(arg, &data->arg);



	return err;

};



long compat_ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

{

	long ret;



	if (!filp->f_op->unlocked_ioctl)

		return -ENOTTY;



	switch (cmd) {

	case COMPAT_ION_IOC_ALLOC:

	{

		struct compat_ion_allocation_data __user *data32;

		struct ion_allocation_data __user *data;

		int err;



		data32 = compat_ptr(arg);

		data = compat_alloc_user_space(sizeof(*data));

		if (data == NULL)

			return -EFAULT;



		err = compat_get_ion_allocation_data(data32, data);

		if (err)

			return err;

		ret = filp->f_op->unlocked_ioctl(filp, ION_IOC_ALLOC,

							(unsigned long)data);

		err = compat_put_ion_allocation_data(data32, data);

		return ret ? ret : err;

	}

	case COMPAT_ION_IOC_FREE:

	{

		struct compat_ion_handle_data __user *data32;

		struct ion_handle_data __user *data;

		int err;



		data32 = compat_ptr(arg);

		data = compat_alloc_user_space(sizeof(*data));

		if (data == NULL)

			return -EFAULT;



		err = compat_get_ion_handle_data(data32, data);

		if (err)

			return err;



		return filp->f_op->unlocked_ioctl(filp, ION_IOC_FREE,

							(unsigned long)data);

	}

	case COMPAT_ION_IOC_CUSTOM: {

		struct compat_ion_custom_data __user *data32;

		struct ion_custom_data __user *data;

		int err;



		data32 = compat_ptr(arg);

		data = compat_alloc_user_space(sizeof(*data));

		if (data == NULL)

			return -EFAULT;



		err = compat_get_ion_custom_data(data32, data);

		if (err)

			return err;



		return filp->f_op->unlocked_ioctl(filp, ION_IOC_CUSTOM,

							(unsigned long)data);

	}

	case ION_IOC_SHARE:

	case ION_IOC_MAP:

	case ION_IOC_IMPORT:

	case ION_IOC_SYNC:

		return filp->f_op->unlocked_ioctl(filp, cmd,

						(unsigned long)compat_ptr(arg));

	default:

		return -ENOIOCTLCMD;

	}

}