libogc/arqueue.c

   1 /*-------------------------------------------------------------
   2
   3 arqueue.c -- ARAM task request queue implementation
   4
   5 Copyright (C) 2004
   6 Michael Wiedenbauer (shagkur)
   7 Dave Murphy (WinterMute)
   8
   9 This software is provided 'as-is', without any express or implied
  10 warranty.  In no event will the authors be held liable for any
  11 damages arising from the use of this software.
  12
  13 Permission is granted to anyone to use this software for any
  14 purpose, including commercial applications, and to alter it and
  15 redistribute it freely, subject to the following restrictions:
  16
  17 1.      The origin of this software must not be misrepresented; you
  18 must not claim that you wrote the original software. If you use
  19 this software in a product, an acknowledgment in the product
  20 documentation would be appreciated but is not required.
  21
  22 2.      Altered source versions must be plainly marked as such, and
  23 must not be misrepresented as being the original software.
  24
  25 3.      This notice may not be removed or altered from any source
  26 distribution.
  27
  28 -------------------------------------------------------------*/
  29
  30
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <lwp.h>
  34
  35 #include "asm.h"
  36 #include "processor.h"
  37 #include "arqueue.h"
  38
  39 //#define _ARQ_DEBUG
  40
  41 static u32 __ARQChunkSize;
  42 static u32 __ARQInitFlag = 0;
  43 static lwpq_t __ARQSyncQueue;
  44
  45 static lwp_queue __ARQReqQueueLo;
  46 static lwp_queue __ARQReqQueueHi;
  47 static ARQRequest *__ARQReqPendingLo;
  48 static ARQRequest *__ARQReqPendingHi;
  49 static ARQCallback __ARQCallbackLo = NULL;
  50 static ARQCallback __ARQCallbackHi = NULL;
  51
  52 static __inline__ void __ARQPopTaskQueueHi()
  53 {
  54         ARQRequest *req;
  55
  56         req = (ARQRequest*)__lwp_queue_getI(&__ARQReqQueueHi);
  57         if(!req) return;
  58
  59         req->state = ARQ_TASK_RUNNING;
  60 #ifdef _ARQ_DEBUG
  61         printf("__ARQPopTaskQueueHi(%02x,%08x,%08x,%d)\n",req->dir,req->aram_addr,req->mram_addr,req->len);
  62 #endif
  63         AR_StartDMA(req->dir,req->mram_addr,req->aram_addr,req->len);
  64         __ARQCallbackHi = req->callback;
  65         __ARQReqPendingHi = req;
  66 }
  67
  68 static void __ARQCallbackDummy(ARQRequest *req)
  69 {
  70 }
  71
  72 static void __ARQCallbackSync(ARQRequest *req)
  73 {
  74         LWP_ThreadBroadcast(__ARQSyncQueue);
  75 }
  76
  77 static void __ARQServiceQueueLo()
  78 {
  79         ARQRequest *req;
  80
  81         if(!__ARQReqPendingLo) {
  82                 req = (ARQRequest*)__lwp_queue_getI(&__ARQReqQueueLo);
  83                 __ARQReqPendingLo = req;
  84         }
  85
  86         req = __ARQReqPendingLo;
  87         if(req) {
  88                 req->state = ARQ_TASK_RUNNING;
  89 #ifdef _ARQ_DEBUG
  90                 printf("__ARQServiceQueueLo(%02x,%08x,%08x,%d,%d)\n",req->dir,req->aram_addr,req->mram_addr,req->len,__ARQChunkSize);
  91 #endif
  92                 if(req->len<=__ARQChunkSize) {
  93                         AR_StartDMA(req->dir,req->mram_addr,req->aram_addr,req->len);
  94                         __ARQCallbackLo = __ARQReqPendingLo->callback;
  95                 } else {
  96                         AR_StartDMA(req->dir,req->mram_addr,req->aram_addr,__ARQChunkSize);
  97                         __ARQReqPendingLo->len -= __ARQChunkSize;
  98                         __ARQReqPendingLo->aram_addr += __ARQChunkSize;
  99                         __ARQReqPendingLo->mram_addr += __ARQChunkSize;
 100                 }
 101         }
 102 }
 103
 104 static void __ARInterruptServiceRoutine()
 105 {
 106         if(__ARQCallbackHi) {
 107                 __ARQReqPendingHi->state = ARQ_TASK_FINISHED;
 108                 __ARQCallbackHi(__ARQReqPendingHi);
 109                 __ARQReqPendingHi = NULL;
 110                 __ARQCallbackHi = NULL;
 111         } else if(__ARQCallbackLo) {
 112                 __ARQReqPendingLo->state = ARQ_TASK_FINISHED;
 113                 __ARQCallbackLo(__ARQReqPendingLo);
 114                 __ARQReqPendingLo = NULL;
 115                 __ARQCallbackLo = NULL;
 116         }
 117         __ARQPopTaskQueueHi();
 118         if(!__ARQReqPendingHi) __ARQServiceQueueLo();
 119 }
 120
 121 void ARQ_Init()
 122 {
 123         u32 level;
 124 #ifdef _ARQ_DEBUG
 125         printf("ARQ_Init(%02x)\n",__ARQInitFlag);
 126 #endif
 127         if(__ARQInitFlag) return;
 128
 129         _CPU_ISR_Disable(level);
 130
 131         __ARQReqPendingLo = NULL;
 132         __ARQReqPendingHi = NULL;
 133         __ARQCallbackLo = NULL;
 134         __ARQCallbackHi = NULL;
 135
 136         __ARQChunkSize = ARQ_DEF_CHUNK_SIZE;
 137
 138         LWP_InitQueue(&__ARQSyncQueue);
 139
 140         __lwp_queue_init_empty(&__ARQReqQueueLo);
 141         __lwp_queue_init_empty(&__ARQReqQueueHi);
 142
 143         AR_RegisterCallback(__ARInterruptServiceRoutine);
 144
 145         __ARQInitFlag = 1;
 146         _CPU_ISR_Restore(level);
 147 }
 148
 149 void ARQ_Reset()
 150 {
 151         u32 level;
 152         _CPU_ISR_Disable(level);
 153         __ARQInitFlag = 0;
 154         _CPU_ISR_Restore(level);
 155 }
 156
 157 void ARQ_SetChunkSize(u32 size)
 158 {
 159         u32 level;
 160         _CPU_ISR_Disable(level);
 161         __ARQChunkSize = (size+31)&~31;
 162         _CPU_ISR_Restore(level);
 163 }
 164
 165 u32 ARQ_GetChunkSize()
 166 {
 167         return __ARQChunkSize;
 168 }
 169
 170 void ARQ_FlushQueue()
 171 {
 172         u32 level;
 173
 174         _CPU_ISR_Disable(level);
 175
 176         __lwp_queue_init_empty(&__ARQReqQueueLo);
 177         __lwp_queue_init_empty(&__ARQReqQueueHi);
 178         if(!__ARQCallbackLo) __ARQReqPendingLo = NULL;
 179
 180         _CPU_ISR_Restore(level);
 181 }
 182
 183 void ARQ_PostRequestAsync(ARQRequest *req,u32 owner,u32 dir,u32 prio,u32 aram_addr,u32 mram_addr,u32 len,ARQCallback cb)
 184 {
 185         u32 level;
 186         ARQRequest *p;
 187
 188         req->state = ARQ_TASK_READY;
 189         req->dir = dir;
 190         req->owner = owner;
 191         req->aram_addr = aram_addr;
 192         req->mram_addr = mram_addr;
 193         req->len = len;
 194         req->prio = prio;
 195         req->callback = (cb==NULL) ? __ARQCallbackDummy : cb;
 196
 197         _CPU_ISR_Disable(level);
 198
 199         if(prio==ARQ_PRIO_LO) __lwp_queue_appendI(&__ARQReqQueueLo,&req->node);
 200         else __lwp_queue_appendI(&__ARQReqQueueHi,&req->node);
 201
 202         if(!__ARQReqPendingLo && !__ARQReqPendingHi) {
 203                 p = (ARQRequest*)__lwp_queue_getI(&__ARQReqQueueHi);
 204                 if(p) {
 205                         p->state = ARQ_TASK_RUNNING;
 206 #ifdef _ARQ_DEBUG
 207                         printf("ARQ_PostRequest(%02x,%08x,%08x,%d)\n",p->dir,p->aram_addr,p->mram_addr,p->len);
 208 #endif
 209                         AR_StartDMA(p->dir,p->mram_addr,p->aram_addr,p->len);
 210                         __ARQCallbackHi = p->callback;
 211                         __ARQReqPendingHi = p;
 212                 }
 213                 if(!__ARQReqPendingHi) __ARQServiceQueueLo();
 214         }
 215         _CPU_ISR_Restore(level);
 216 }
 217
 218 void ARQ_PostRequest(ARQRequest *req,u32 owner,u32 dir,u32 prio,u32 aram_addr,u32 mram_addr,u32 len)
 219 {
 220         u32 level;
 221
 222         ARQ_PostRequestAsync(req,owner,dir,prio,aram_addr,mram_addr,len,__ARQCallbackSync);
 223
 224         _CPU_ISR_Disable(level);
 225         while(req->state!=ARQ_TASK_FINISHED) {
 226                 LWP_ThreadSleep(__ARQSyncQueue);
 227         }
 228         _CPU_ISR_Restore(level);
 229 }
 230
 231 void ARQ_RemoveRequest(ARQRequest *req)
 232 {
 233         u32 level;
 234
 235         _CPU_ISR_Disable(level);
 236         __lwp_queue_extractI(&req->node);
 237         if(__ARQReqPendingLo && __ARQReqPendingLo==req && __ARQCallbackLo==NULL) __ARQReqPendingLo = NULL;
 238         _CPU_ISR_Restore(level);
 239 }
 240
 241 u32 ARQ_RemoveOwnerRequest(u32 owner)
 242 {
 243         u32 level,cnt;
 244         ARQRequest *req;
 245
 246         _CPU_ISR_Disable(level);
 247
 248         cnt = 0;
 249         req = (ARQRequest*)__ARQReqQueueHi.first;
 250         while(req!=(ARQRequest*)__lwp_queue_tail(&__ARQReqQueueHi)) {
 251                 if(req->owner==owner) {
 252                         __lwp_queue_extractI(&req->node);
 253                         cnt++;
 254                 }
 255                 req = (ARQRequest*)req->node.next;
 256         }
 257
 258         req = (ARQRequest*)__ARQReqQueueLo.first;
 259         while(req!=(ARQRequest*)__lwp_queue_tail(&__ARQReqQueueLo)) {
 260                 if(req->owner==owner) {
 261                         __lwp_queue_extractI(&req->node);
 262                         cnt++;
 263                 }
 264                 req = (ARQRequest*)req->node.next;
 265         }
 266         if(__ARQReqPendingLo && __ARQReqPendingLo==req && __ARQCallbackLo==NULL) __ARQReqPendingLo = NULL;
 267         _CPU_ISR_Restore(level);
 268
 269         return cnt;
 270 }
 271