Subversion Repositories thor

// ============================================================================

//        __

//   \\__/ o\    (C) 2012-2015  Robert Finch, Stratford

//    \  __ /    All rights reserved.

//     \/_//     robfinch<remove>@finitron.ca

//       ||

//

// TCB.c

// Task Control Block related functions.

//

// This source file is free software: you can redistribute it and/or modify 

// it under the terms of the GNU Lesser General Public License as published 

// by the Free Software Foundation, either version 3 of the License, or     

// (at your option) any later version.                                      

//                                                                          

// This source file is distributed in the hope that it will be useful,      

// but WITHOUT ANY WARRANTY; without even the implied warranty of           

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            

// GNU General Public License for more details.                             

//                                                                          

// You should have received a copy of the GNU General Public License        

// along with this program.  If not, see <http://www.gnu.org/licenses/>.    

//                                                                          

// ============================================================================

//

#include "config.h"

#include "const.h"

#include "types.h"

#include "proto.h"

extern char hasUltraHighPriorityTasks;

extern pascal prtdbl(double);

TCB tcbs[NR_TCB];

hTCB freeTCB;

hTCB TimeoutList;

hTCB readyQ[8];

pascal int chkTCB(TCB *p)

{

    asm {

        lw    r1,32[bp]

        //chk   r1,r1,b48

    }

}

naked TCB *GetRunningTCBPtr()

{

    asm {

        mov   r1,tr

        rts

    }

}

naked hTCB GetRunningTCB()

{

    asm {

        subui  r1,tr,#tcbs_

        shrui  r1,r1,#12

        rts

    }

}

pascal void SetRunningTCB(hTCB ht)

{

     asm {

         lw      tr,32[bp]

         shli    tr,tr,#12

         addui   tr,tr,#tcbs_

     }

}

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

pascal int InsertIntoReadyList(hTCB ht)

{

    hTCB hq;

    TCB *p, *q;

        asm {

                ldi   r1,#70

                sc    r1,hs:LEDS

        }

        if (ht < 0 || ht >= NR_TCB)

                throw E_BadHandle;

    p = &tcbs[ht];

        if (p->priority > 077 || p->priority < 000)

                throw E_BadPriority;

        asm {

                ldi   r1,#71

                sc    r1,hs:LEDS

        }

        if (p->priority < 003)

           hasUltraHighPriorityTasks |= (1 << p->priority);

        p->status = TS_READY;

        hq = readyQ[p->priority>>3];

        asm {

                ldi   r1,#72

                sc    r1,hs:LEDS

        }

        // Ready list empty ?

        if (hq<0) {

                p->next = ht;

                p->prev = ht;

                readyQ[p->priority>>3] = ht;

                return E_Ok;

        }

        asm {

                ldi   r1,#75

                sc    r1,hs:LEDS

        }

        // Insert at tail of list

        q = &tcbs[hq];

        p->next = hq;

        p->prev = q->prev;

        tcbs[q->prev].next = ht;

        q->prev = ht;

        asm {

                ldi   r1,#77

                sc    r1,hs:LEDS

        }

        return E_Ok;

}

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

pascal int RemoveFromReadyList(hTCB ht)

{

    TCB *t;

        if (ht < 0 || ht >= NR_TCB)

                throw E_BadHandle;

    t = &tcbs[ht];

        if (t->priority > 077 || t->priority < 000)

                throw E_BadPriority;

    if (ht==readyQ[t->priority>>3])

       readyQ[t->priority>>3] = t->next;

    if (ht==readyQ[t->priority>>3])

       readyQ[t->priority>>3] = -1;

    tcbs[t->next].prev = t->prev;

    tcbs[t->prev].next = t->next;

    t->next = -1;

    t->prev = -1;

    t->status = TS_NONE;

    return E_Ok;

}

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

pascal int InsertIntoTimeoutList(hTCB ht, int to)

{

    TCB *p, *q, *t;

        if (ht < 0 || ht >= NR_TCB)

                throw E_BadHandle;

    t = &tcbs[ht];

    if (TimeoutList<0) {

        t->timeout = to;

        TimeoutList = ht;

        t->next = -1;

        t->prev = -1;

        return E_Ok;

    }

    q = null;

    p = &tcbs[TimeoutList];

    while (to > p->timeout) {

        to -= p->timeout;

        q = p;

        p = &tcbs[p->next];

    }

    t->next = p - tcbs;

    t->prev = q - tcbs;

    if (p) {

        p->timeout -= to;

        p->prev = ht;

    }

    if (q)

        q->next = ht;

    else

        TimeoutList = ht;

    t->status |= TS_TIMEOUT;

    return E_Ok;

};

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

pascal int RemoveFromTimeoutList(hTCB ht)

{

    TCB *t;

        if (ht < 0 || ht >= NR_TCB)

                throw E_BadHandle;

    t = &tcbs[ht];

    if (t->next) {

       tcbs[t->next].prev = t->prev;

       tcbs[t->next].timeout += t->timeout;

    }

    if (t->prev >= 0)

       tcbs[t->prev].next = t->next;

    t->status = TS_NONE;

    t->next = -1;

    t->prev = -1;

}

// ----------------------------------------------------------------------------

// Pop the top entry from the timeout list.

// ----------------------------------------------------------------------------

hTCB PopTimeoutList()

{

    TCB *p;

    hTCB h;

    h = TimeoutList;

    if (TimeoutList >= 0 && TimeoutList < NR_TCB) {

        TimeoutList = tcbs[TimeoutList].next;

        if (TimeoutList >= 0 && TimeoutList < NR_TCB)

            tcbs[TimeoutList].prev = -1;

    }

    return h;

}

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

void DumpTaskList()

{

     TCB *p, *q;

     int n;

     int kk;

     hTCB h, j;

//     printf("pi is ");

//     prtdbl(3.141592653589793238,10,6,'E');

     printf("CPU Pri Stat Task Prev Next Timeout\r\n");

     for (n = 0; n < 8; n++) {

         h = readyQ[n];

         if (h >= 0 && h < NR_TCB) {

             q = &tcbs[h];

             p = q;

             kk = 0;

             do {

//                 if (!chkTCB(p)) {

//                     printf("Bad TCB (%X)\r\n", p);

//                     break;

//                 }

                   j = p - tcbs;

                 printf("%3d %3d  %02X  %04X %04X %04X %08X %08X\r\n", p->affinity, p->priority, p->status, (int)j, p->prev, p->next, p->timeout, p->ticks);

                 if (p->next < 0 || p->next >= NR_TCB)

                     break;

                 p = &tcbs[p->next];

                 if (getcharNoWait()==3)

                    goto j1;

                 kk = kk + 1;

             } while (p != q && kk < 10);

         }

     }

     printf("Waiting tasks\r\n");

     h = TimeoutList;

     while (h >= 0 && h < NR_TCB) {

         p = &tcbs[h];

         printf("%3d %3d  %02X  %04X %04X %04X %08X %08X\r\n", p->affinity, p->priority, p->status, (int)j, p->prev, p->next, p->timeout, p->ticks);

         h = p->next;

         if (getcharNoWait()==3)

            goto j1;

     }

j1:  ;

}