sys/dev/acpica/Osd/OsdSchedule.c

   1 /*-
   2  * Copyright (c) 2000 Michael Smith
   3  * Copyright (c) 2000 BSDi
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  *      $FreeBSD: src/sys/dev/acpica/Osd/OsdSchedule.c,v 1.23.6.1 2003/08/22 20:49:21 jhb Exp $
  28  *      $DragonFly: src/sys/dev/acpica/Osd/Attic/OsdSchedule.c,v 1.3 2004/05/05 22:18:09 dillon Exp $
  29  */
  30
  31 /*
  32  * 6.3 : Scheduling services
  33  */
  34
  35 #include "acpi.h"
  36
  37 #include "opt_acpi.h"
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/bus.h>
  41 #include <sys/interrupt.h>
  42 #include <sys/kernel.h>
  43 #include <sys/kthread.h>
  44 #include <sys/malloc.h>
  45 #include <sys/proc.h>
  46 #include <sys/taskqueue.h>
  47 #include <machine/clock.h>
  48
  49 #include <sys/bus.h>
  50
  51 #include <dev/acpica/acpivar.h>
  52
  53 #define _COMPONENT      ACPI_OS_SERVICES
  54 ACPI_MODULE_NAME("SCHEDULE")
  55
  56 /*
  57  * This is a little complicated due to the fact that we need to build and then
  58  * free a 'struct task' for each task we enqueue.
  59  */
  60
  61 MALLOC_DEFINE(M_ACPITASK, "acpitask", "ACPI deferred task");
  62
  63 static void     AcpiOsExecuteQueue(void *arg, int pending);
  64
  65 struct acpi_task {
  66     struct task                 at_task;
  67     OSD_EXECUTION_CALLBACK      at_function;
  68     void                        *at_context;
  69 };
  70
  71 struct acpi_task_queue {
  72     STAILQ_ENTRY(acpi_task_queue) at_q;
  73     struct acpi_task            *at;
  74 };
  75
  76 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
  77 /*
  78  * Private task queue definition for ACPI
  79  */
  80 TASKQUEUE_DECLARE(acpi);
  81 static void     *taskqueue_acpi_ih;
  82
  83 static void
  84 taskqueue_acpi_enqueue(void *context)
  85 {
  86     swi_sched(taskqueue_acpi_ih, 0);
  87 }
  88
  89 static void
  90 taskqueue_acpi_run(void *dummy)
  91 {
  92     taskqueue_run(taskqueue_acpi);
  93 }
  94
  95 TASKQUEUE_DEFINE(acpi, taskqueue_acpi_enqueue, 0,
  96                  swi_add(NULL, "acpitaskq", taskqueue_acpi_run, NULL,
  97                      SWI_TQ, 0, &taskqueue_acpi_ih));
  98
  99 #ifdef ACPI_USE_THREADS
 100 STAILQ_HEAD(, acpi_task_queue) acpi_task_queue;
 101 static struct mtx       acpi_task_mtx;
 102
 103 static void
 104 acpi_task_thread(void *arg)
 105 {
 106     struct acpi_task_queue      *atq;
 107     OSD_EXECUTION_CALLBACK      Function;
 108     void                        *Context;
 109
 110     for (;;) {
 111         mtx_lock(&acpi_task_mtx);
 112         if ((atq = STAILQ_FIRST(&acpi_task_queue)) == NULL) {
 113             msleep(&acpi_task_queue, &acpi_task_mtx, PCATCH, "actask", 0);
 114             mtx_unlock(&acpi_task_mtx);
 115             continue;
 116         }
 117
 118         STAILQ_REMOVE_HEAD(&acpi_task_queue, at_q);
 119         mtx_unlock(&acpi_task_mtx);
 120
 121         Function = (OSD_EXECUTION_CALLBACK)atq->at->at_function;
 122         Context = atq->at->at_context;
 123
 124         mtx_lock(&Giant);
 125         Function(Context);
 126
 127         free(atq->at, M_ACPITASK);
 128         free(atq, M_ACPITASK);
 129         mtx_unlock(&Giant);
 130     }
 131
 132     kthread_exit(0);
 133 }
 134
 135 int
 136 acpi_task_thread_init(void)
 137 {
 138     int         i, err;
 139     struct proc *acpi_kthread_proc;
 140
 141     err = 0;
 142     STAILQ_INIT(&acpi_task_queue);
 143     mtx_init(&acpi_task_mtx, "ACPI task", NULL, MTX_DEF);
 144
 145     for (i = 0; i < ACPI_MAX_THREADS; i++) {
 146         err = kthread_create(acpi_task_thread, NULL, &acpi_kthread_proc,
 147                              0, 0, "acpi_task%d", i);
 148         if (err != 0) {
 149             printf("%s: kthread_create failed(%d)\n", __func__, err);
 150             break;
 151         }
 152     }
 153     return (err);
 154 }
 155 #endif
 156 #endif
 157
 158 ACPI_STATUS
 159 AcpiOsQueueForExecution(UINT32 Priority, OSD_EXECUTION_CALLBACK Function, void *Context)
 160 {
 161     struct acpi_task    *at;
 162     int pri;
 163
 164     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 165
 166     if (Function == NULL)
 167         return_ACPI_STATUS(AE_BAD_PARAMETER);
 168
 169     /* note: Interrupt Context */
 170     at = malloc(sizeof(*at), M_ACPITASK, M_INTWAIT | M_ZERO);
 171     at->at_function = Function;
 172     at->at_context = Context;
 173
 174     switch (Priority) {
 175     case OSD_PRIORITY_GPE:
 176         pri = 4;
 177         break;
 178     case OSD_PRIORITY_HIGH:
 179         pri = 3;
 180         break;
 181     case OSD_PRIORITY_MED:
 182         pri = 2;
 183         break;
 184     case OSD_PRIORITY_LO:
 185         pri = 1;
 186         break;
 187     default:
 188         free(at, M_ACPITASK);
 189         return_ACPI_STATUS(AE_BAD_PARAMETER);
 190     }
 191     TASK_INIT(&at->at_task, pri, AcpiOsExecuteQueue, at);
 192
 193 #if defined(__DragonFly__) || __FreeBSD_version < 500000
 194     taskqueue_enqueue(taskqueue_swi, (struct task *)at);
 195 #else
 196     taskqueue_enqueue(taskqueue_acpi, (struct task *)at);
 197 #endif
 198     return_ACPI_STATUS(AE_OK);
 199 }
 200
 201 static void
 202 AcpiOsExecuteQueue(void *arg, int pending)
 203 {
 204     struct acpi_task            *at;
 205     struct acpi_task_queue      *atq;
 206     OSD_EXECUTION_CALLBACK      Function;
 207     void                        *Context;
 208
 209     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 210
 211     at = (struct acpi_task *)arg;
 212     atq = NULL;
 213     Function = NULL;
 214     Context = NULL;
 215
 216 #ifdef ACPI_USE_THREADS
 217     atq = malloc(sizeof(*atq), M_ACPITASK, M_INTWAIT);
 218     atq->at = at;
 219
 220     mtx_lock(&acpi_task_mtx);
 221     STAILQ_INSERT_TAIL(&acpi_task_queue, atq, at_q);
 222     mtx_unlock(&acpi_task_mtx);
 223     wakeup_one(&acpi_task_queue);
 224 #else
 225     Function = (OSD_EXECUTION_CALLBACK)at->at_function;
 226     Context = at->at_context;
 227
 228     Function(Context);
 229     free(at, M_ACPITASK);
 230 #endif
 231
 232     return_VOID;
 233 }
 234
 235 /*
 236  * We don't have any sleep granularity better than hz, so
 237  * make do with that.
 238  */
 239 void
 240 AcpiOsSleep (UINT32 Seconds, UINT32 Milliseconds)
 241 {
 242     int         timo;
 243     static int  dummy;
 244
 245     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 246
 247     timo = (Seconds * hz) + Milliseconds * hz / 1000;
 248     if (timo == 0)
 249         timo = 1;
 250     tsleep(&dummy, 0, "acpislp", timo);
 251     return_VOID;
 252 }
 253
 254 void
 255 AcpiOsStall (UINT32 Microseconds)
 256 {
 257     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 258
 259     DELAY(Microseconds);
 260     return_VOID;
 261 }
 262
 263 UINT32
 264 AcpiOsGetThreadId (void)
 265 {
 266     struct proc *p;
 267     /* XXX do not add FUNCTION_TRACE here, results in recursive call */
 268
 269     p = curproc;
 270 #if defined(__DragonFly__) || __FreeBSD_version < 500000
 271     if (p == NULL)
 272         p = &proc0;
 273 #endif
 274     KASSERT(p != NULL, ("%s: curproc is NULL!", __func__));
 275     return(p->p_pid + 1);       /* can't return 0 */
 276 }