1 /*
2 * Copyright (C) 2010-2014, 2016-2017 ARM Limited. All rights reserved.
3 *
4 * This program is free software and is provided to you under the terms of the GNU General Public License version 2
5 * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence.
6 *
7 * A copy of the licence is included with the program, and can also be obtained from Free Software
8 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
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 static struct workqueue_struct *mali_wq_normal = NULL;
41 static struct workqueue_struct *mali_wq_high = NULL;
42 #endif
43
44 static void _mali_osk_wq_work_func(struct work_struct *work);
45
_mali_osk_wq_init(void)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
_mali_osk_wq_flush(void)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
_mali_osk_wq_term(void)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
_mali_osk_wq_create_work(_mali_osk_wq_work_handler_t handler,void * data)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
_mali_osk_wq_create_work_high_pri(_mali_osk_wq_work_handler_t handler,void * data)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
_mali_osk_wq_delete_work(_mali_osk_wq_work_t * work)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
_mali_osk_wq_delete_work_nonflush(_mali_osk_wq_work_t * work)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
_mali_osk_wq_schedule_work(_mali_osk_wq_work_t * work)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
_mali_osk_wq_schedule_work_high_pri(_mali_osk_wq_work_t * work)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
_mali_osk_wq_work_func(struct work_struct * work)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 highest Dynamic priority of the thread so that the Jobs depending
176 ** on this thread could be scheduled in time. Without this, this thread might
177 ** sometimes need to wait for some threads in user mode to finish its round-robin
178 ** time, causing *bubble* in the Mali pipeline. Thanks to the new implementation
179 ** of high-priority workqueue in new kernel, this only happens in older kernel.
180 */
181 if (MALI_TRUE == work_object->high_pri) {
182 set_user_nice(current, -19);
183 }
184 #endif
185 #endif /* MALI_LICENSE_IS_GPL */
186
187 work_object->handler(work_object->data);
188 }
189
_mali_osk_wq_delayed_work_func(struct work_struct * work)190 static void _mali_osk_wq_delayed_work_func(struct work_struct *work)
191 {
192 mali_osk_wq_delayed_work_object_t *work_object;
193
194 work_object = _MALI_OSK_CONTAINER_OF(work, mali_osk_wq_delayed_work_object_t, work.work);
195 work_object->handler(work_object->data);
196 }
197
_mali_osk_wq_delayed_create_work(_mali_osk_wq_work_handler_t handler,void * data)198 mali_osk_wq_delayed_work_object_t *_mali_osk_wq_delayed_create_work(_mali_osk_wq_work_handler_t handler, void *data)
199 {
200 mali_osk_wq_delayed_work_object_t *work = kmalloc(sizeof(mali_osk_wq_delayed_work_object_t), GFP_KERNEL);
201
202 if (NULL == work) return NULL;
203
204 work->handler = handler;
205 work->data = data;
206
207 INIT_DELAYED_WORK(&work->work, _mali_osk_wq_delayed_work_func);
208
209 return work;
210 }
211
_mali_osk_wq_delayed_delete_work_nonflush(_mali_osk_wq_delayed_work_t * work)212 void _mali_osk_wq_delayed_delete_work_nonflush(_mali_osk_wq_delayed_work_t *work)
213 {
214 mali_osk_wq_delayed_work_object_t *work_object = (mali_osk_wq_delayed_work_object_t *)work;
215 kfree(work_object);
216 }
217
_mali_osk_wq_delayed_cancel_work_async(_mali_osk_wq_delayed_work_t * work)218 void _mali_osk_wq_delayed_cancel_work_async(_mali_osk_wq_delayed_work_t *work)
219 {
220 mali_osk_wq_delayed_work_object_t *work_object = (mali_osk_wq_delayed_work_object_t *)work;
221 cancel_delayed_work(&work_object->work);
222 }
223
_mali_osk_wq_delayed_cancel_work_sync(_mali_osk_wq_delayed_work_t * work)224 void _mali_osk_wq_delayed_cancel_work_sync(_mali_osk_wq_delayed_work_t *work)
225 {
226 mali_osk_wq_delayed_work_object_t *work_object = (mali_osk_wq_delayed_work_object_t *)work;
227 cancel_delayed_work_sync(&work_object->work);
228 }
229
_mali_osk_wq_delayed_schedule_work(_mali_osk_wq_delayed_work_t * work,u32 delay)230 void _mali_osk_wq_delayed_schedule_work(_mali_osk_wq_delayed_work_t *work, u32 delay)
231 {
232 mali_osk_wq_delayed_work_object_t *work_object = (mali_osk_wq_delayed_work_object_t *)work;
233
234 #if MALI_LICENSE_IS_GPL
235 queue_delayed_work(mali_wq_normal, &work_object->work, delay);
236 #else
237 schedule_delayed_work(&work_object->work, delay);
238 #endif
239
240 }
241