firmware/kernel.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Björn Stenberg
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include "kernel.h"
  22 #include "thread.h"
  23 #include "sh7034.h"
  24 #include "system.h"
  25 #include "panic.h"
  26
  27 long current_tick = 0;
  28
  29 void (*tick_funcs[MAX_NUM_TICK_TASKS])(void);
  30
  31 static void tick_start(unsigned int interval_in_ms);
  32
  33 /* This array holds all queues that are initiated. It is used for broadcast. */
  34 static struct event_queue *all_queues[32];
  35 static int num_queues;
  36
  37 void sleep(int ticks) __attribute__ ((section(".icode")));
  38 void queue_wait(struct event_queue *q, struct event *ev) __attribute__ ((section(".icode")));;
  39
  40 /****************************************************************************
  41  * Standard kernel stuff
  42  ****************************************************************************/
  43 void kernel_init(void)
  44 {
  45     /* Init the threading API */
  46     init_threads();
  47
  48     memset(tick_funcs, 0, sizeof(tick_funcs));
  49
  50     num_queues = 0;
  51     memset(all_queues, 0, sizeof(all_queues));
  52
  53     tick_start(1000/HZ);
  54 }
  55
  56 void sleep(int ticks)
  57 {
  58     /* Always sleep at least 1 tick */
  59     int timeout = current_tick + ticks + 1;
  60
  61     while (TIME_BEFORE( current_tick, timeout )) {
  62         yield();
  63     }
  64 }
  65
  66 void yield(void)
  67 {
  68     switch_thread();
  69 }
  70
  71 /****************************************************************************
  72  * Interrupt level setting
  73  ****************************************************************************/
  74 int set_irq_level(int level)
  75 {
  76     int i;
  77     /* Read the old level and set the new one */
  78     asm volatile ("stc sr, %0" : "=r" (i));
  79     asm volatile ("ldc %0, sr" : : "r" (level << 4));
  80     return (i >> 4) & 0x0f;
  81 }
  82
  83 /****************************************************************************
  84  * Queue handling stuff
  85  ****************************************************************************/
  86 void queue_init(struct event_queue *q)
  87 {
  88     q->read = 0;
  89     q->write = 0;
  90
  91     /* Add it to the all_queues array */
  92     all_queues[num_queues++] = q;
  93 }
  94
  95 void queue_wait(struct event_queue *q, struct event *ev)
  96 {
  97     while(q->read == q->write)
  98     {
  99         switch_thread();
 100     }
 101
 102     *ev = q->events[(q->read++) & QUEUE_LENGTH_MASK];
 103 }
 104
 105 void queue_post(struct event_queue *q, int id, void *data)
 106 {
 107     int wr;
 108     int oldlevel;
 109
 110     oldlevel = set_irq_level(15);
 111     wr = (q->write++) & QUEUE_LENGTH_MASK;
 112
 113     q->events[wr].id = id;
 114     q->events[wr].data = data;
 115     set_irq_level(oldlevel);
 116 }
 117
 118 bool queue_empty(struct event_queue* q)
 119 {
 120     return ( q->read == q->write );
 121 }
 122
 123 int queue_broadcast(int id, void *data)
 124 {
 125    int i;
 126
 127    for(i = 0;i < num_queues;i++)
 128    {
 129       queue_post(all_queues[i], id, data);
 130    }
 131
 132    return num_queues;
 133 }
 134
 135 /****************************************************************************
 136  * Timer tick
 137  ****************************************************************************/
 138 static void tick_start(unsigned int interval_in_ms)
 139 {
 140     unsigned int count;
 141
 142     count = FREQ / 1000 / 8 * interval_in_ms;
 143
 144     if(count > 0xffff)
 145     {
 146         panicf("Error! The tick interval is too long (%d ms)\n",
 147                interval_in_ms);
 148         return;
 149     }
 150
 151     /* We are using timer 0 */
 152
 153     TSTR &= ~0x01; /* Stop the timer */
 154     TSNC &= ~0x01; /* No synchronization */
 155     TMDR &= ~0x01; /* Operate normally */
 156
 157     TCNT0 = 0;   /* Start counting at 0 */
 158     GRA0 = count;
 159     TCR0 = 0x23; /* Clear at GRA match, sysclock/8 */
 160
 161     /* Enable interrupt on level 1 */
 162     IPRC = (IPRC & ~0x00f0) | 0x0010;
 163
 164     TSR0 &= ~0x01;
 165     TIER0 = 0xf9; /* Enable GRA match interrupt */
 166
 167     TSTR |= 0x01; /* Start timer 1 */
 168 }
 169
 170 #pragma interrupt
 171 void IMIA0(void)
 172 {
 173     int i;
 174
 175     /* Run through the list of tick tasks */
 176     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 177     {
 178         if(tick_funcs[i])
 179         {
 180             tick_funcs[i]();
 181         }
 182     }
 183
 184     current_tick++;
 185
 186     TSR0 &= ~0x01;
 187 }
 188
 189 int tick_add_task(void (*f)(void))
 190 {
 191     int i;
 192     int oldlevel = set_irq_level(15);
 193
 194     /* Add a task if there is room */
 195     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 196     {
 197         if(tick_funcs[i] == NULL)
 198         {
 199             tick_funcs[i] = f;
 200             set_irq_level(oldlevel);
 201             return 0;
 202         }
 203     }
 204     set_irq_level(oldlevel);
 205     panicf("Error! tick_add_task(): out of tasks");
 206     return -1;
 207 }
 208
 209 int tick_remove_task(void (*f)(void))
 210 {
 211     int i;
 212     int oldlevel = set_irq_level(15);
 213
 214     /* Remove a task if it is there */
 215     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 216     {
 217         if(tick_funcs[i] == f)
 218         {
 219             tick_funcs[i] = NULL;
 220             set_irq_level(oldlevel);
 221             return 0;
 222         }
 223     }
 224
 225     set_irq_level(oldlevel);
 226     return -1;
 227 }
 228
 229 /****************************************************************************
 230  * Simple mutex functions
 231  ****************************************************************************/
 232 void mutex_init(struct mutex *m)
 233 {
 234     m->locked = false;
 235 }
 236
 237 void mutex_lock(struct mutex *m)
 238 {
 239     /* Wait until the lock is open... */
 240     while(m->locked)
 241         yield();
 242
 243     /* ...and lock it */
 244     m->locked = true;
 245 }
 246
 247 void mutex_unlock(struct mutex *m)
 248 {
 249     m->locked = false;
 250 }