arch/ppc-chrp/efika/kernel/scheduler.c

   1 /*
   2     Copyright © 1995-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <asm/mpc5200b.h>
   7 #include <aros/kernel.h>
   8 #include <aros/libcall.h>
   9 #include <exec/execbase.h>
  10 #include <hardware/intbits.h>
  11
  12 #include "exec_intern.h"
  13 #include "etask.h"
  14 #include "syscall.h"
  15
  16 #include "kernel_intern.h"
  17
  18 AROS_LH0(KRN_SchedType, KrnGetScheduler,
  19          struct KernelBase *, KernelBase, 1, Kernel)
  20 {
  21     AROS_LIBFUNC_INIT
  22
  23     return SCHED_RR;
  24
  25     AROS_LIBFUNC_EXIT
  26 }
  27
  28 AROS_LH1(void, KrnSetScheduler,
  29          AROS_LHA(KRN_SchedType, sched, D0),
  30          struct KernelBase *, KernelBase, 2, Kernel)
  31 {
  32     AROS_LIBFUNC_INIT
  33
  34     /* Cannot set scheduler yet */
  35
  36     AROS_LIBFUNC_EXIT
  37 }
  38
  39 AROS_LH0(void, KrnCause,
  40          struct KernelBase *, KernelBase, 3, Kernel)
  41 {
  42     AROS_LIBFUNC_INIT
  43
  44     asm volatile("li %%r3,%0; sc"::"i"(SC_CAUSE):"memory","r3");
  45
  46     AROS_LIBFUNC_EXIT
  47 }
  48
  49 AROS_LH0(void , KrnDispatch,
  50          struct KernelBase *, KernelBase, 4, Kernel)
  51 {
  52     AROS_LIBFUNC_INIT
  53
  54
  55     asm volatile("li %%r3,%0; sc"::"i"(SC_DISPATCH):"memory","r3");
  56
  57     AROS_LIBFUNC_EXIT
  58 }
  59
  60 AROS_LH0(void, KrnSwitch,
  61          struct KernelBase *, KernelBase, 5, Kernel)
  62 {
  63     AROS_LIBFUNC_INIT
  64
  65     asm volatile("li %%r3,%0; sc"::"i"(SC_SWITCH):"memory","r3");
  66
  67     AROS_LIBFUNC_EXIT
  68 }
  69
  70 AROS_LH0(void, KrnSchedule,
  71          struct KernelBase *, KernelBase, 6, Kernel)
  72 {
  73     AROS_LIBFUNC_INIT
  74
  75     asm volatile("li %%r3,%0; sc"::"i"(SC_SCHEDULE):"memory","r3");
  76
  77     AROS_LIBFUNC_EXIT
  78 }
  79
  80 /*
  81  * Task dispatcher. Basically it may be the same one no matter what scheduling algorithm is used
  82  */
  83 void core_Dispatch(regs_t *regs)
  84 {
  85     volatile struct ExecBase *SysBase = getSysBase();
  86     struct Task *task;
  87
  88     if (SysBase)
  89     {
  90         wrmsr(rdmsr() & ~MSR_EE);
  91
  92         /*
  93          * Is the list of ready tasks empty? Well, increment the idle switch cound and halt CPU.
  94          * It should be extended by some plugin mechanism which would put CPU and whole machine
  95          * into some more sophisticated sleep states (ACPI?)
  96          */
  97         while (IsListEmpty(&SysBase->TaskReady))
  98         {
  99 //            SysBase->IdleCount++;
 100             SysBase->AttnResched |= ARF_AttnSwitch;
 101
 102             //D(bug("[KRN] TaskReady list empty. Sleeping for a while...\n"));
 103             /* Sleep almost forever ;) */
 104
 105             wrmsr(rdmsr() | MSR_EE);
 106             asm volatile("sync");
 107 //            wrmsr(rdmsr() | MSR_POW);
 108 //            asm volatile("isync");
 109
 110             if (SysBase->SysFlags & SFF_SoftInt)
 111             {
 112                 core_Cause(SysBase);
 113             }
 114         }
 115
 116         SysBase->DispCount++;
 117
 118         /* Get the first task from the TaskReady list, and populate it's settings through Sysbase */
 119         task = (struct Task *)REMHEAD(&SysBase->TaskReady);
 120         SysBase->ThisTask = task;
 121         SysBase->Elapsed = SysBase->Quantum;
 122         SysBase->SysFlags &= ~0x2000;
 123         task->tc_State = TS_RUN;
 124         SysBase->IDNestCnt = task->tc_IDNestCnt;
 125
 126         //D(bug("[KRN] New task = %p (%s)\n", task, task->tc_Node.ln_Name));
 127
 128         /* Handle tasks's flags */
 129         if (task->tc_Flags & TF_EXCEPT)
 130             Exception();
 131
 132         /* Store the launch time */
 133         GetIntETask(task)->iet_private1 = mftbu();
 134
 135         if (task->tc_Flags & TF_LAUNCH)
 136         {
 137             AROS_UFC1(void, task->tc_Launch,
 138                       AROS_UFCA(struct ExecBase *, SysBase, A6));
 139         }
 140
 141         /* Restore the task's state */
 142         regs = task->tc_UnionETask.tc_ETask->et_RegFrame;
 143
 144         if (SysBase->IDNestCnt < 0)
 145                 regs->srr1 |= MSR_EE;
 146
 147         /* Copy the fpu, mmx, xmm state */
 148 #warning FIXME: Change to the lazy saving of the FPU state!!!!
 149 #warning TODO: No FPU support yet!!!!!!! Yay, it sucks! :-D
 150
 151     }
 152
 153     regs->srr1 &= ~MSR_POW;
 154     /* Leave interrupt and jump to the new task */
 155     core_LeaveInterrupt(regs);
 156 }
 157
 158 extern struct Task *idle_task;
 159
 160 void core_Switch(regs_t *regs)
 161 {
 162     struct ExecBase *SysBase = getSysBase();
 163     struct Task *task;
 164     context_t *ctx = (context_t *)regs;
 165     if (SysBase)
 166     {
 167         /* Disable interrupts for a while */
 168         wrmsr(rdmsr() & ~MSR_EE);
 169
 170         task = SysBase->ThisTask;
 171
 172         //D(bug("[KRN] Old task = %p (%s)\n", task, task->tc_Node.ln_Name));
 173
 174         /* Copy current task's context into the ETask structure */
 175         memmove(task->tc_UnionETask.tc_ETask->et_RegFrame, regs, sizeof(context_t));
 176
 177         /* Copy the fpu, mmx, xmm state */
 178
 179 #warning FIXME: Change to the lazy saving of the FPU state!!!!
 180 #warning TODO: Write the damn FPU handling at all!!!!!!!! ;-D LOL
 181
 182         /* store IDNestCnt into tasks's structure */
 183         task->tc_IDNestCnt = SysBase->IDNestCnt;
 184         task->tc_SPReg = regs->gpr[1];
 185
 186         /* And enable interrupts */
 187         SysBase->IDNestCnt = -1;
 188
 189 //              if (task->tc_Node.ln_Pri < 127)
 190 //                      task->tc_Node.ln_Pri++;
 191 //
 192 //        if (SysBase->Elapsed <= 1)
 193 //              if (task->tc_Node.ln_Pri > -125)
 194 //                      task->tc_Node.ln_Pri--;
 195
 196 //        wrmsr(rdmsr() | MSR_EE);
 197
 198         /* FIXME */
 199 #if (0)
 200         /* Task says byebye. Update the CPU Time now. */
 201         GetIntETask(task)->iet_CpuTime += mftbu() - GetIntETask(task)->iet_private1;
 202 #endif
 203         /* TF_SWITCH flag set? Call the switch routine */
 204         if (task->tc_Flags & TF_SWITCH)
 205         {
 206             AROS_UFC1(void, task->tc_Switch,
 207                       AROS_UFCA(struct ExecBase *, SysBase, A6));
 208         }
 209     }
 210
 211     core_Dispatch(regs);
 212 }
 213
 214 /*
 215  * Schedule the currently running task away. Put it into the TaskReady list
 216  * in some smart way. This function is subject of change and it will be probably replaced
 217  * by some plugin system in the future
 218  */
 219 void core_Schedule(regs_t *regs)
 220 {
 221     struct ExecBase *SysBase = getSysBase();
 222     struct Task *task;
 223
 224     if (SysBase)
 225     {
 226         /* Disable interrupts for a while */
 227         wrmsr(rdmsr() & ~MSR_EE); // CLI
 228
 229         task = SysBase->ThisTask;
 230
 231         /* Clear the pending switch flag. */
 232         SysBase->AttnResched &= ~ARF_AttnSwitch;
 233
 234         /* If task has pending exception, reschedule it so that the dispatcher may handle the exception */
 235         if (!(task->tc_Flags & TF_EXCEPT))
 236         {
 237             /* Is the TaskReady empty? If yes, then the running task is the only one. Let it work */
 238             if (IsListEmpty(&SysBase->TaskReady))
 239                 core_LeaveInterrupt(regs);
 240
 241             /* Does the TaskReady list contains tasks with priority equal or lower than current task?
 242              * If so, then check further... */
 243             if (((struct Task*)GetHead(&SysBase->TaskReady))->tc_Node.ln_Pri <= task->tc_Node.ln_Pri)
 244             {
 245                 /* If the running task did not used it's whole quantum yet, let it work */
 246                 if (!(SysBase->SysFlags & 0x2000))
 247                 {
 248                     core_LeaveInterrupt(regs);
 249                 }
 250             }
 251         }
 252
 253 #if 0
 254         if (task != idle_task)
 255         {
 256                 /* almost no CPU time used? Good. Increase the pri */
 257                 if (SysBase->Elapsed == SysBase->Quantum)
 258                 {
 259 //                      if (task->tc_Node.ln_Pri < (GetIntETask(task)->iet_OrigPri) + 5)
 260 //                              task->tc_Node.ln_Pri++;
 261                 }
 262                 else
 263                 {
 264                         if (task->tc_Node.ln_Pri > (GetIntETask(task)->iet_OrigPri) - 5)
 265                                 task->tc_Node.ln_Pri--;
 266                 }
 267         }
 268 #endif
 269
 270         /*
 271          * If we got here, then the rescheduling is necessary.
 272          * Put the task into the TaskReady list.
 273          */
 274         task->tc_State = TS_READY;
 275         Enqueue(&SysBase->TaskReady, (struct Node *)task);
 276     }
 277
 278     /* Select new task to run */
 279     core_Switch(regs);
 280 }
 281
 282 /*
 283  * Leave the interrupt. This function receives the register frame used to leave the supervisor
 284  * mode. It never returns and reschedules the task if it was asked for.
 285  */
 286 void core_ExitInterrupt(regs_t *regs)
 287 {
 288     /* Powermode was on? Turn it off now */
 289     regs->srr1 &= ~MSR_POW;
 290
 291     /* Going back into supervisor mode? Then exit immediatelly */
 292     if (!(regs->srr1 & MSR_PR))
 293     {
 294         core_LeaveInterrupt(regs);
 295     }
 296     else
 297     {
 298         /* Prepare to go back into user mode */
 299         struct ExecBase *SysBase = getSysBase();
 300
 301         if (SysBase)
 302         {
 303             /* Soft interrupt requested? It's high time to do it */
 304             if (SysBase->SysFlags & SFF_SoftInt)
 305                 core_Cause(SysBase);
 306
 307             /* If task switching is disabled, leave immediatelly */
 308             if (SysBase->TDNestCnt >= 0)
 309             {
 310                 core_LeaveInterrupt(regs);
 311             }
 312             else
 313             {
 314                 /*
 315                  * Do not disturb task if it's not necessary.
 316                  * Reschedule only if switch pending flag is set. Exit otherwise.
 317                  */
 318                 if (SysBase->AttnResched & ARF_AttnSwitch)
 319                 {
 320                     core_Schedule(regs);
 321                 }
 322                 else
 323                     core_LeaveInterrupt(regs);
 324             }
 325         }
 326         else
 327             core_LeaveInterrupt(regs);
 328     }
 329 }
 330
 331 void core_Cause(struct ExecBase *SysBase)
 332 {
 333     struct IntVector *iv = &SysBase->IntVects[INTB_SOFTINT];
 334
 335     /* If the SoftInt vector in SysBase is set, call it. It will do the rest for us */
 336     if (iv->iv_Code)
 337     {
 338         AROS_INTC1(iv->iv_Code, iv->iv_Data);
 339     }
 340 }