drivers/gpu/arm/mali400/mali/linux/mali_osk_wq.c

   1 /*
   2  * Copyright (C) 2010-2014, 2016 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
  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 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
 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
 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
 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
 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
 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
 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 }