[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / misc / mediatek / gpu / mt8127 / mali / mali / linux / mali_osk_wq.c

/*
 * This confidential and proprietary software may be used only as
 * authorised by a licensing agreement from ARM Limited
 * (C) COPYRIGHT 2008-2013 ARM Limited
 * ALL RIGHTS RESERVED
 * The entire notice above must be reproduced on all authorised
 * copies and copies may only be made to the extent permitted
 * by a licensing agreement from ARM Limited.
 */

/**
 * @file mali_osk_wq.c
 * Implementation of the OS abstraction layer for the kernel device driver
 */

#include <linux/slab.h>	/* For memory allocation */
#include <linux/workqueue.h>
#include <linux/version.h>
#include <linux/sched.h>

#include "mali_osk.h"
#include "mali_kernel_common.h"
#include "mali_kernel_license.h"
#include "mali_kernel_linux.h"

typedef struct _mali_osk_wq_work_s {
	_mali_osk_wq_work_handler_t handler;
	void *data;
	mali_bool high_pri;
	struct work_struct work_handle;
} mali_osk_wq_work_object_t;

typedef struct _mali_osk_wq_delayed_work_s {
	_mali_osk_wq_work_handler_t handler;
	void *data;
	struct delayed_work work;
} mali_osk_wq_delayed_work_object_t;

#if MALI_LICENSE_IS_GPL
struct workqueue_struct *mali_wq_normal = NULL;
struct workqueue_struct *mali_wq_high = NULL;
#endif

static void _mali_osk_wq_work_func(struct work_struct *work);

_mali_osk_errcode_t _mali_osk_wq_init(void)
{
#if MALI_LICENSE_IS_GPL
	MALI_DEBUG_ASSERT(NULL == mali_wq_normal);
	MALI_DEBUG_ASSERT(NULL == mali_wq_high);

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
	mali_wq_normal = alloc_workqueue("mali", WQ_UNBOUND, 0);
	mali_wq_high = alloc_workqueue("mali_high_pri", WQ_HIGHPRI | WQ_UNBOUND, 0);
#else
	mali_wq_normal = create_workqueue("mali");
	mali_wq_high = create_workqueue("mali_high_pri");
#endif
	if (NULL == mali_wq_normal || NULL == mali_wq_high) {
		MALI_PRINT_ERROR(("Unable to create Mali workqueues\n"));

		if (mali_wq_normal) destroy_workqueue(mali_wq_normal);
		if (mali_wq_high)   destroy_workqueue(mali_wq_high);

		mali_wq_normal = NULL;
		mali_wq_high   = NULL;

		return _MALI_OSK_ERR_FAULT;
	}
#endif /* MALI_LICENSE_IS_GPL */

	return _MALI_OSK_ERR_OK;
}

void _mali_osk_wq_flush(void)
{
#if MALI_LICENSE_IS_GPL
	flush_workqueue(mali_wq_high);
	flush_workqueue(mali_wq_normal);
#else
	flush_scheduled_work();
#endif
}

void _mali_osk_wq_term(void)
{
#if MALI_LICENSE_IS_GPL
	MALI_DEBUG_ASSERT(NULL != mali_wq_normal);
	MALI_DEBUG_ASSERT(NULL != mali_wq_high);

	flush_workqueue(mali_wq_normal);
	destroy_workqueue(mali_wq_normal);

	flush_workqueue(mali_wq_high);
	destroy_workqueue(mali_wq_high);

	mali_wq_normal = NULL;
	mali_wq_high   = NULL;
#else
	flush_scheduled_work();
#endif
}

_mali_osk_wq_work_t *_mali_osk_wq_create_work( _mali_osk_wq_work_handler_t handler, void *data )
{
	mali_osk_wq_work_object_t *work = kmalloc(sizeof(mali_osk_wq_work_object_t), GFP_KERNEL);

	if (NULL == work) return NULL;

	work->handler = handler;
	work->data = data;
	work->high_pri = MALI_FALSE;

	INIT_WORK( &work->work_handle, _mali_osk_wq_work_func);

	return work;
}

_mali_osk_wq_work_t *_mali_osk_wq_create_work_high_pri( _mali_osk_wq_work_handler_t handler, void *data )
{
	mali_osk_wq_work_object_t *work = kmalloc(sizeof(mali_osk_wq_work_object_t), GFP_KERNEL);

	if (NULL == work) return NULL;

	work->handler = handler;
	work->data = data;
	work->high_pri = MALI_TRUE;

	INIT_WORK( &work->work_handle, _mali_osk_wq_work_func );

	return work;
}

void _mali_osk_wq_delete_work( _mali_osk_wq_work_t *work )
{
	mali_osk_wq_work_object_t *work_object = (mali_osk_wq_work_object_t *)work;
	_mali_osk_wq_flush();
	kfree(work_object);
}

void _mali_osk_wq_delete_work_nonflush( _mali_osk_wq_work_t *work )
{
	mali_osk_wq_work_object_t *work_object = (mali_osk_wq_work_object_t *)work;
	kfree(work_object);
}

void _mali_osk_wq_schedule_work( _mali_osk_wq_work_t *work )
{
	mali_osk_wq_work_object_t *work_object = (mali_osk_wq_work_object_t *)work;
#if MALI_LICENSE_IS_GPL
	queue_work(mali_wq_normal, &work_object->work_handle);
#else
	schedule_work(&work_object->work_handle);
#endif
}

void _mali_osk_wq_schedule_work_high_pri( _mali_osk_wq_work_t *work )
{
	mali_osk_wq_work_object_t *work_object = (mali_osk_wq_work_object_t *)work;
#if MALI_LICENSE_IS_GPL
	queue_work(mali_wq_high, &work_object->work_handle);
#else
	schedule_work(&work_object->work_handle);
#endif
}

static void _mali_osk_wq_work_func( struct work_struct *work )
{
	mali_osk_wq_work_object_t *work_object;

	work_object = _MALI_OSK_CONTAINER_OF(work, mali_osk_wq_work_object_t, work_handle);

#if MALI_LICENSE_IS_GPL
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
	/* We want higher priority than the Dynamic Priority, setting it to the lowest of the RT priorities */
	if (MALI_TRUE == work_object->high_pri) {
		set_user_nice(current, -19);
	}
#endif
#endif /* MALI_LICENSE_IS_GPL */

	work_object->handler(work_object->data);
}

static void _mali_osk_wq_delayed_work_func( struct work_struct *work )
{
	mali_osk_wq_delayed_work_object_t *work_object;

	work_object = _MALI_OSK_CONTAINER_OF(work, mali_osk_wq_delayed_work_object_t, work.work);
	work_object->handler(work_object->data);
}

mali_osk_wq_delayed_work_object_t *_mali_osk_wq_delayed_create_work( _mali_osk_wq_work_handler_t handler, void *data)
{
	mali_osk_wq_delayed_work_object_t *work = kmalloc(sizeof(mali_osk_wq_delayed_work_object_t), GFP_KERNEL);

	if (NULL == work) return NULL;

	work->handler = handler;
	work->data = data;

	INIT_DELAYED_WORK(&work->work, _mali_osk_wq_delayed_work_func);

	return work;
}

void _mali_osk_wq_delayed_delete_work_nonflush( _mali_osk_wq_delayed_work_t *work )
{
	mali_osk_wq_delayed_work_object_t *work_object = (mali_osk_wq_delayed_work_object_t *)work;
	kfree(work_object);
}

void _mali_osk_wq_delayed_cancel_work_async( _mali_osk_wq_delayed_work_t *work )
{
	mali_osk_wq_delayed_work_object_t *work_object = (mali_osk_wq_delayed_work_object_t *)work;
	cancel_delayed_work(&work_object->work);
}

void _mali_osk_wq_delayed_cancel_work_sync( _mali_osk_wq_delayed_work_t *work )
{
	mali_osk_wq_delayed_work_object_t *work_object = (mali_osk_wq_delayed_work_object_t *)work;
	cancel_delayed_work_sync(&work_object->work);
}

void _mali_osk_wq_delayed_schedule_work( _mali_osk_wq_delayed_work_t *work, u32 delay )
{
	mali_osk_wq_delayed_work_object_t *work_object = (mali_osk_wq_delayed_work_object_t *)work;

#if MALI_LICENSE_IS_GPL
	queue_delayed_work(mali_wq_normal, &work_object->work, delay);
#else
	schedule_delayed_work(&work_object->work, delay);
#endif

}
Commit	Line	Data
6fa3eb70 S	1	/*
	2	* This confidential and proprietary software may be used only as
	3	* authorised by a licensing agreement from ARM Limited
	4	* (C) COPYRIGHT 2008-2013 ARM Limited
	5	* ALL RIGHTS RESERVED
	6	* The entire notice above must be reproduced on all authorised
	7	* copies and copies may only be made to the extent permitted
	8	* by a licensing agreement from ARM Limited.
	9	*/
	10
	11	/**
	12	* @file mali_osk_wq.c
	13	* Implementation of the OS abstraction layer for the kernel device driver
	14	*/
	15
	16	#include <linux/slab.h> /* For memory allocation */
	17	#include <linux/workqueue.h>
	18	#include <linux/version.h>
	19	#include <linux/sched.h>
	20
	21	#include "mali_osk.h"
	22	#include "mali_kernel_common.h"
	23	#include "mali_kernel_license.h"
	24	#include "mali_kernel_linux.h"
	25
	26	typedef struct _mali_osk_wq_work_s {
	27	_mali_osk_wq_work_handler_t handler;
	28	void *data;
	29	mali_bool high_pri;
	30	struct work_struct work_handle;
	31	} mali_osk_wq_work_object_t;
	32
	33	typedef struct _mali_osk_wq_delayed_work_s {
	34	_mali_osk_wq_work_handler_t handler;
	35	void *data;
	36	struct delayed_work work;
	37	} mali_osk_wq_delayed_work_object_t;
	38
	39	#if MALI_LICENSE_IS_GPL
	40	struct workqueue_struct *mali_wq_normal = NULL;
	41	struct workqueue_struct *mali_wq_high = NULL;
	42	#endif
	43
	44	static void _mali_osk_wq_work_func(struct work_struct *work);
	45
	46	_mali_osk_errcode_t _mali_osk_wq_init(void)
	47	{
	48	#if MALI_LICENSE_IS_GPL
	49	MALI_DEBUG_ASSERT(NULL == mali_wq_normal);
	50	MALI_DEBUG_ASSERT(NULL == mali_wq_high);
	51
	52	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
	53	mali_wq_normal = alloc_workqueue("mali", WQ_UNBOUND, 0);
	54	mali_wq_high = alloc_workqueue("mali_high_pri", WQ_HIGHPRI \| WQ_UNBOUND, 0);
	55	#else
	56	mali_wq_normal = create_workqueue("mali");
	57	mali_wq_high = create_workqueue("mali_high_pri");
	58	#endif
	59	if (NULL == mali_wq_normal \|\| NULL == mali_wq_high) {
	60	MALI_PRINT_ERROR(("Unable to create Mali workqueues\n"));
	61
	62	if (mali_wq_normal) destroy_workqueue(mali_wq_normal);
	63	if (mali_wq_high) destroy_workqueue(mali_wq_high);
	64
65	mali_wq_normal = NULL;
66	mali_wq_high = NULL;
67
68	return _MALI_OSK_ERR_FAULT;
69	}
70	#endif /* MALI_LICENSE_IS_GPL */
71
72	return _MALI_OSK_ERR_OK;
73	}
74
75	void _mali_osk_wq_flush(void)
76	{
77	#if MALI_LICENSE_IS_GPL
78	flush_workqueue(mali_wq_high);
79	flush_workqueue(mali_wq_normal);
80	#else
81	flush_scheduled_work();
82	#endif
83	}
84
85	void _mali_osk_wq_term(void)
86	{
87	#if MALI_LICENSE_IS_GPL
88	MALI_DEBUG_ASSERT(NULL != mali_wq_normal);
89	MALI_DEBUG_ASSERT(NULL != mali_wq_high);
90
91	flush_workqueue(mali_wq_normal);
92	destroy_workqueue(mali_wq_normal);
93
94	flush_workqueue(mali_wq_high);
95	destroy_workqueue(mali_wq_high);
96
97	mali_wq_normal = NULL;
98	mali_wq_high = NULL;
99	#else
100	flush_scheduled_work();
101	#endif
102	}
103
104	_mali_osk_wq_work_t _mali_osk_wq_create_work( _mali_osk_wq_work_handler_t handler, void data )
105	{
106	mali_osk_wq_work_object_t *work = kmalloc(sizeof(mali_osk_wq_work_object_t), GFP_KERNEL);
107
108	if (NULL == work) return NULL;
109
110	work->handler = handler;
111	work->data = data;
112	work->high_pri = MALI_FALSE;
113
114	INIT_WORK( &work->work_handle, _mali_osk_wq_work_func);
115
116	return work;
117	}
118
119	_mali_osk_wq_work_t _mali_osk_wq_create_work_high_pri( _mali_osk_wq_work_handler_t handler, void data )
120	{
121	mali_osk_wq_work_object_t *work = kmalloc(sizeof(mali_osk_wq_work_object_t), GFP_KERNEL);
122
123	if (NULL == work) return NULL;
124
125	work->handler = handler;
126	work->data = data;
127	work->high_pri = MALI_TRUE;
128
129	INIT_WORK( &work->work_handle, _mali_osk_wq_work_func );
130
131	return work;
132	}
133
134	void _mali_osk_wq_delete_work( _mali_osk_wq_work_t *work )
135	{
136	mali_osk_wq_work_object_t work_object = (mali_osk_wq_work_object_t )work;
137	_mali_osk_wq_flush();
138	kfree(work_object);
139	}
140
141	void _mali_osk_wq_delete_work_nonflush( _mali_osk_wq_work_t *work )
142	{
143	mali_osk_wq_work_object_t work_object = (mali_osk_wq_work_object_t )work;
144	kfree(work_object);
145	}
146
147	void _mali_osk_wq_schedule_work( _mali_osk_wq_work_t *work )
148	{
149	mali_osk_wq_work_object_t work_object = (mali_osk_wq_work_object_t )work;
150	#if MALI_LICENSE_IS_GPL
151	queue_work(mali_wq_normal, &work_object->work_handle);
152	#else
153	schedule_work(&work_object->work_handle);
154	#endif
155	}
156
157	void _mali_osk_wq_schedule_work_high_pri( _mali_osk_wq_work_t *work )
158	{
159	mali_osk_wq_work_object_t work_object = (mali_osk_wq_work_object_t )work;
160	#if MALI_LICENSE_IS_GPL
161	queue_work(mali_wq_high, &work_object->work_handle);
162	#else
163	schedule_work(&work_object->work_handle);
164	#endif
165	}
166
167	static void _mali_osk_wq_work_func( struct work_struct *work )
168	{
169	mali_osk_wq_work_object_t *work_object;
170
171	work_object = _MALI_OSK_CONTAINER_OF(work, mali_osk_wq_work_object_t, work_handle);
172
173	#if MALI_LICENSE_IS_GPL
174	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
175	/* We want higher priority than the Dynamic Priority, setting it to the lowest of the RT priorities */
176	if (MALI_TRUE == work_object->high_pri) {
177	set_user_nice(current, -19);
178	}
179	#endif
180	#endif /* MALI_LICENSE_IS_GPL */
181
182	work_object->handler(work_object->data);
183	}
184
185	static void _mali_osk_wq_delayed_work_func( struct work_struct *work )
186	{
187	mali_osk_wq_delayed_work_object_t *work_object;
188
189	work_object = _MALI_OSK_CONTAINER_OF(work, mali_osk_wq_delayed_work_object_t, work.work);
190	work_object->handler(work_object->data);
191	}
192
193	mali_osk_wq_delayed_work_object_t _mali_osk_wq_delayed_create_work( _mali_osk_wq_work_handler_t handler, void data)
194	{
195	mali_osk_wq_delayed_work_object_t *work = kmalloc(sizeof(mali_osk_wq_delayed_work_object_t), GFP_KERNEL);
196
197	if (NULL == work) return NULL;
198
199	work->handler = handler;
200	work->data = data;
201
202	INIT_DELAYED_WORK(&work->work, _mali_osk_wq_delayed_work_func);
203
204	return work;
205	}
206
207	void _mali_osk_wq_delayed_delete_work_nonflush( _mali_osk_wq_delayed_work_t *work )
208	{
209	mali_osk_wq_delayed_work_object_t work_object = (mali_osk_wq_delayed_work_object_t )work;
210	kfree(work_object);
211	}
212
213	void _mali_osk_wq_delayed_cancel_work_async( _mali_osk_wq_delayed_work_t *work )
214	{
215	mali_osk_wq_delayed_work_object_t work_object = (mali_osk_wq_delayed_work_object_t )work;
216	cancel_delayed_work(&work_object->work);
217	}
218
219	void _mali_osk_wq_delayed_cancel_work_sync( _mali_osk_wq_delayed_work_t *work )
220	{
221	mali_osk_wq_delayed_work_object_t work_object = (mali_osk_wq_delayed_work_object_t )work;
222	cancel_delayed_work_sync(&work_object->work);
223	}
224
225	void _mali_osk_wq_delayed_schedule_work( _mali_osk_wq_delayed_work_t *work, u32 delay )
226	{
227	mali_osk_wq_delayed_work_object_t work_object = (mali_osk_wq_delayed_work_object_t )work;
228
229	#if MALI_LICENSE_IS_GPL
230	queue_delayed_work(mali_wq_normal, &work_object->work, delay);
231	#else
232	schedule_delayed_work(&work_object->work, delay);
233	#endif
234
235	}