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 "cpu.h"
  24 #include "system.h"
  25 #include "panic.h"
  26
  27 long current_tick = 0;
  28
  29 static 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         sleep_thread();
  63     }
  64     wake_up_thread();
  65 }
  66
  67 void yield(void)
  68 {
  69     switch_thread();
  70     wake_up_thread();
  71 }
  72
  73 /****************************************************************************
  74  * Queue handling stuff
  75  ****************************************************************************/
  76 void queue_init(struct event_queue *q)
  77 {
  78     q->read = 0;
  79     q->write = 0;
  80
  81     /* Add it to the all_queues array */
  82     all_queues[num_queues++] = q;
  83 }
  84
  85 void queue_wait(struct event_queue *q, struct event *ev)
  86 {
  87     while(q->read == q->write)
  88     {
  89         sleep_thread();
  90     }
  91     wake_up_thread();
  92
  93     *ev = q->events[(q->read++) & QUEUE_LENGTH_MASK];
  94 }
  95
  96 void queue_wait_w_tmo(struct event_queue *q, struct event *ev, int ticks)
  97 {
  98     unsigned int timeout = current_tick + ticks;
  99
 100     while(q->read == q->write && TIME_BEFORE( current_tick, timeout ))
 101     {
 102         sleep_thread();
 103     }
 104     wake_up_thread();
 105
 106     if(q->read != q->write)
 107     {
 108         *ev = q->events[(q->read++) & QUEUE_LENGTH_MASK];
 109     }
 110     else
 111     {
 112         ev->id = SYS_TIMEOUT;
 113     }
 114 }
 115
 116 void queue_post(struct event_queue *q, int id, void *data)
 117 {
 118     int wr;
 119     int oldlevel;
 120
 121     oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
 122     wr = (q->write++) & QUEUE_LENGTH_MASK;
 123
 124     q->events[wr].id = id;
 125     q->events[wr].data = data;
 126     set_irq_level(oldlevel);
 127 }
 128
 129 bool queue_empty(const struct event_queue* q)
 130 {
 131     return ( q->read == q->write );
 132 }
 133
 134 void queue_clear(struct event_queue* q)
 135 {
 136     int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
 137     q->read = 0;
 138     q->write = 0;
 139     set_irq_level(oldlevel);
 140 }
 141
 142 int queue_broadcast(int id, void *data)
 143 {
 144    int i;
 145
 146    for(i = 0;i < num_queues;i++)
 147    {
 148       queue_post(all_queues[i], id, data);
 149    }
 150
 151    return num_queues;
 152 }
 153
 154 /****************************************************************************
 155  * Timer tick
 156  ****************************************************************************/
 157 #if CONFIG_CPU == SH7034
 158 static void tick_start(unsigned int interval_in_ms)
 159 {
 160     unsigned int count;
 161
 162     count = FREQ * interval_in_ms / 1000 / 8;
 163
 164     if(count > 0xffff)
 165     {
 166         panicf("Error! The tick interval is too long (%d ms)\n",
 167                interval_in_ms);
 168         return;
 169     }
 170
 171     /* We are using timer 0 */
 172
 173     TSTR &= ~0x01; /* Stop the timer */
 174     TSNC &= ~0x01; /* No synchronization */
 175     TMDR &= ~0x01; /* Operate normally */
 176
 177     TCNT0 = 0;   /* Start counting at 0 */
 178     GRA0 = count;
 179     TCR0 = 0x23; /* Clear at GRA match, sysclock/8 */
 180
 181     /* Enable interrupt on level 1 */
 182     IPRC = (IPRC & ~0x00f0) | 0x0010;
 183
 184     TSR0 &= ~0x01;
 185     TIER0 = 0xf9; /* Enable GRA match interrupt */
 186
 187     TSTR |= 0x01; /* Start timer 1 */
 188 }
 189
 190 #pragma interrupt
 191 void IMIA0(void)
 192 {
 193     int i;
 194
 195     /* Run through the list of tick tasks */
 196     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 197     {
 198         if(tick_funcs[i])
 199         {
 200             tick_funcs[i]();
 201         }
 202     }
 203
 204     current_tick++;
 205     wake_up_thread();
 206
 207     TSR0 &= ~0x01;
 208 }
 209 #elif CONFIG_CPU == MCF5249
 210 static void tick_start(unsigned int interval_in_ms)
 211 {
 212     unsigned int count;
 213
 214     count = FREQ/2 * interval_in_ms / 1000 / 16;
 215
 216     if(count > 0xffff)
 217     {
 218         panicf("Error! The tick interval is too long (%d ms)\n",
 219                interval_in_ms);
 220         return;
 221     }
 222
 223     /* We are using timer 0 */
 224
 225     TRR0 = count; /* The reference count */
 226     TCN0 = 0; /* reset the timer */
 227     TMR0 = 0x001d; /* no prescaler, restart, CLK/16, enabled */
 228
 229     TER0 = 0xff; /* Clear all events */
 230
 231     ICR0 = (ICR0 & 0xff00ffff) | 0x008c0000; /* Interrupt on level 3.0 */
 232     IMR &= ~0x200;
 233 }
 234
 235 void TIMER0(void) __attribute__ ((interrupt_handler));
 236 void TIMER0(void)
 237 {
 238     int i;
 239
 240     /* Run through the list of tick tasks */
 241     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 242     {
 243         if(tick_funcs[i])
 244         {
 245             tick_funcs[i]();
 246         }
 247     }
 248
 249     current_tick++;
 250     wake_up_thread();
 251
 252     TER0 = 0xff; /* Clear all events */
 253 }
 254
 255 #elif CONFIG_CPU == TCC730
 256
 257 void TIMER0(void)
 258 {
 259     int i;
 260
 261     /* Run through the list of tick tasks */
 262     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 263     {
 264         if(tick_funcs[i])
 265         {
 266             tick_funcs[i]();
 267         }
 268     }
 269
 270     current_tick++;
 271     wake_up_thread();
 272
 273     /* re-enable timer by clearing the counter */
 274     TACON |= 0x80;
 275 }
 276
 277 static void tick_start(unsigned int interval_in_ms)
 278 {
 279     long count;
 280     count = (long)FREQ * (long)interval_in_ms / 1000 / 16;
 281
 282     if(count > 0xffffL)
 283     {
 284         panicf("Error! The tick interval is too long (%dms->%x)\n",
 285                interval_in_ms, count);
 286         return;
 287     }
 288
 289     /* Use timer A */
 290     TAPRE = 0x0;
 291     TADATA = count;
 292
 293     TACON = 0x89;
 294     /* counter clear; */
 295     /* interval mode; */
 296     /* TICS = F(osc) / 16 */
 297     /* TCS = internal clock */
 298     /* enable */
 299
 300     /* enable the interrupt */
 301     interrupt_vector[2] = TIMER0;
 302     IMR0 |= (1<<2);
 303 }
 304
 305 #endif
 306
 307 int tick_add_task(void (*f)(void))
 308 {
 309     int i;
 310     int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
 311
 312     /* Add a task if there is room */
 313     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 314     {
 315         if(tick_funcs[i] == NULL)
 316         {
 317             tick_funcs[i] = f;
 318             set_irq_level(oldlevel);
 319             return 0;
 320         }
 321     }
 322     set_irq_level(oldlevel);
 323     panicf("Error! tick_add_task(): out of tasks");
 324     return -1;
 325 }
 326
 327 int tick_remove_task(void (*f)(void))
 328 {
 329     int i;
 330     int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
 331
 332     /* Remove a task if it is there */
 333     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 334     {
 335         if(tick_funcs[i] == f)
 336         {
 337             tick_funcs[i] = NULL;
 338             set_irq_level(oldlevel);
 339             return 0;
 340         }
 341     }
 342
 343     set_irq_level(oldlevel);
 344     return -1;
 345 }
 346
 347 /****************************************************************************
 348  * Simple mutex functions
 349  ****************************************************************************/
 350 void mutex_init(struct mutex *m)
 351 {
 352     m->locked = false;
 353 }
 354
 355 void mutex_lock(struct mutex *m)
 356 {
 357     /* Wait until the lock is open... */
 358     while(m->locked)
 359         sleep_thread();
 360     wake_up_thread();
 361
 362     /* ...and lock it */
 363     m->locked = true;
 364 }
 365
 366 void mutex_unlock(struct mutex *m)
 367 {
 368     m->locked = false;
 369 }