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 "config.h"
  22 #include "kernel.h"
  23 #include "thread.h"
  24 #include "cpu.h"
  25 #include "system.h"
  26 #include "panic.h"
  27
  28 #if ((CONFIG_CPU != PP5020) && (CONFIG_CPU != PP5002)) || !defined(BOOTLOADER)
  29 long current_tick = 0;
  30 #endif
  31
  32 static void (*tick_funcs[MAX_NUM_TICK_TASKS])(void);
  33
  34 /* This array holds all queues that are initiated. It is used for broadcast. */
  35 static struct event_queue *all_queues[32];
  36 static int num_queues;
  37
  38 void sleep(int ticks) ICODE_ATTR;
  39 void queue_wait(struct event_queue *q, struct event *ev) ICODE_ATTR;
  40
  41 /****************************************************************************
  42  * Standard kernel stuff
  43  ****************************************************************************/
  44 void kernel_init(void)
  45 {
  46     /* Init the threading API */
  47     init_threads();
  48
  49     memset(tick_funcs, 0, sizeof(tick_funcs));
  50
  51     num_queues = 0;
  52     memset(all_queues, 0, sizeof(all_queues));
  53
  54     tick_start(1000/HZ);
  55 }
  56
  57 void sleep(int ticks)
  58 {
  59     /* Always sleep at least 1 tick */
  60     int timeout = current_tick + ticks + 1;
  61
  62     while (TIME_BEFORE( current_tick, timeout )) {
  63         sleep_thread();
  64     }
  65     wake_up_thread();
  66 }
  67
  68 void yield(void)
  69 {
  70     switch_thread();
  71     wake_up_thread();
  72 }
  73
  74 /****************************************************************************
  75  * Queue handling stuff
  76  ****************************************************************************/
  77 void queue_init(struct event_queue *q)
  78 {
  79     q->read = 0;
  80     q->write = 0;
  81
  82     /* Add it to the all_queues array */
  83     all_queues[num_queues++] = q;
  84 }
  85
  86 void queue_delete(struct event_queue *q)
  87 {
  88     int i;
  89     bool found = false;
  90
  91     /* Find the queue to be deleted */
  92     for(i = 0;i < num_queues;i++)
  93     {
  94         if(all_queues[i] == q)
  95         {
  96             found = true;
  97             break;
  98         }
  99     }
 100
 101     if(found)
 102     {
 103         /* Move the following queues up in the list */
 104         for(;i < num_queues-1;i++)
 105         {
 106             all_queues[i] = all_queues[i+1];
 107         }
 108
 109         num_queues--;
 110     }
 111 }
 112
 113 void queue_wait(struct event_queue *q, struct event *ev)
 114 {
 115     while(q->read == q->write)
 116     {
 117         sleep_thread();
 118     }
 119     wake_up_thread();
 120
 121     *ev = q->events[(q->read++) & QUEUE_LENGTH_MASK];
 122 }
 123
 124 void queue_wait_w_tmo(struct event_queue *q, struct event *ev, int ticks)
 125 {
 126     unsigned int timeout = current_tick + ticks;
 127
 128     while(q->read == q->write && TIME_BEFORE( current_tick, timeout ))
 129     {
 130         sleep_thread();
 131     }
 132     wake_up_thread();
 133
 134     if(q->read != q->write)
 135     {
 136         *ev = q->events[(q->read++) & QUEUE_LENGTH_MASK];
 137     }
 138     else
 139     {
 140         ev->id = SYS_TIMEOUT;
 141     }
 142 }
 143
 144 void queue_post(struct event_queue *q, long id, void *data)
 145 {
 146     int wr;
 147     int oldlevel;
 148
 149     oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
 150     wr = (q->write++) & QUEUE_LENGTH_MASK;
 151
 152     q->events[wr].id = id;
 153     q->events[wr].data = data;
 154     set_irq_level(oldlevel);
 155 }
 156
 157 bool queue_empty(const struct event_queue* q)
 158 {
 159     return ( q->read == q->write );
 160 }
 161
 162 void queue_clear(struct event_queue* q)
 163 {
 164     int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
 165     q->read = 0;
 166     q->write = 0;
 167     set_irq_level(oldlevel);
 168 }
 169
 170 int queue_broadcast(long id, void *data)
 171 {
 172    int i;
 173
 174    for(i = 0;i < num_queues;i++)
 175    {
 176       queue_post(all_queues[i], id, data);
 177    }
 178
 179    return num_queues;
 180 }
 181
 182 /****************************************************************************
 183  * Timer tick
 184  ****************************************************************************/
 185 #if CONFIG_CPU == SH7034
 186 void tick_start(unsigned int interval_in_ms)
 187 {
 188     unsigned long count;
 189
 190     count = CPU_FREQ * interval_in_ms / 1000 / 8;
 191
 192     if(count > 0x10000)
 193     {
 194         panicf("Error! The tick interval is too long (%d ms)\n",
 195                interval_in_ms);
 196         return;
 197     }
 198
 199     /* We are using timer 0 */
 200
 201     TSTR &= ~0x01; /* Stop the timer */
 202     TSNC &= ~0x01; /* No synchronization */
 203     TMDR &= ~0x01; /* Operate normally */
 204
 205     TCNT0 = 0;   /* Start counting at 0 */
 206     GRA0 = (unsigned short)(count - 1);
 207     TCR0 = 0x23; /* Clear at GRA match, sysclock/8 */
 208
 209     /* Enable interrupt on level 1 */
 210     IPRC = (IPRC & ~0x00f0) | 0x0010;
 211
 212     TSR0 &= ~0x01;
 213     TIER0 = 0xf9; /* Enable GRA match interrupt */
 214
 215     TSTR |= 0x01; /* Start timer 1 */
 216 }
 217
 218 void IMIA0(void) __attribute__ ((interrupt_handler));
 219 void IMIA0(void)
 220 {
 221     int i;
 222
 223     /* Run through the list of tick tasks */
 224     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 225     {
 226         if(tick_funcs[i])
 227         {
 228             tick_funcs[i]();
 229         }
 230     }
 231
 232     current_tick++;
 233     wake_up_thread();
 234
 235     TSR0 &= ~0x01;
 236 }
 237 #elif defined(CPU_COLDFIRE)
 238 void tick_start(unsigned int interval_in_ms)
 239 {
 240     unsigned long count;
 241     int prescale;
 242
 243     count = CPU_FREQ/2 * interval_in_ms / 1000 / 16;
 244
 245     if(count > 0x10000)
 246     {
 247         panicf("Error! The tick interval is too long (%d ms)\n",
 248                interval_in_ms);
 249         return;
 250     }
 251
 252     prescale = cpu_frequency / CPU_FREQ;
 253     /* Note: The prescaler is later adjusted on-the-fly on CPU frequency
 254        changes within timer.c */
 255
 256     /* We are using timer 0 */
 257
 258     TRR0 = (unsigned short)(count - 1); /* The reference count */
 259     TCN0 = 0; /* reset the timer */
 260     TMR0 = 0x001d | ((unsigned short)(prescale - 1) << 8);
 261            /* restart, CLK/16, enabled, prescaler */
 262
 263     TER0 = 0xff; /* Clear all events */
 264
 265     ICR1 = 0x8c; /* Interrupt on level 3.0 */
 266     IMR &= ~0x200;
 267 }
 268
 269 void TIMER0(void) __attribute__ ((interrupt_handler));
 270 void TIMER0(void)
 271 {
 272     int i;
 273
 274     /* Run through the list of tick tasks */
 275     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 276     {
 277         if(tick_funcs[i])
 278         {
 279             tick_funcs[i]();
 280         }
 281     }
 282
 283     current_tick++;
 284     wake_up_thread();
 285
 286     TER0 = 0xff; /* Clear all events */
 287 }
 288
 289 #elif CONFIG_CPU == TCC730
 290
 291 void TIMER0(void)
 292 {
 293     int i;
 294
 295     /* Keep alive (?)
 296      * If this is not done, power goes down when DC is unplugged.
 297      */
 298     if (current_tick % 2 == 0)
 299         P8 |= 1;
 300     else
 301         P8 &= ~1;
 302
 303     /* Run through the list of tick tasks */
 304     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 305     {
 306         if(tick_funcs[i])
 307         {
 308             tick_funcs[i]();
 309         }
 310     }
 311
 312     current_tick++;
 313     wake_up_thread();
 314
 315     /* re-enable timer by clearing the counter */
 316     TACON |= 0x80;
 317 }
 318
 319 void tick_start(unsigned int interval_in_ms)
 320 {
 321     long count;
 322     count = (long)FREQ * (long)interval_in_ms / 1000 / 16;
 323
 324     if(count > 0xffffL)
 325     {
 326         panicf("Error! The tick interval is too long (%dms->%lx)\n",
 327                interval_in_ms, count);
 328         return;
 329     }
 330
 331     /* Use timer A */
 332     TAPRE = 0x0;
 333     TADATA = count;
 334
 335     TACON = 0x89;
 336     /* counter clear; */
 337     /* interval mode; */
 338     /* TICS = F(osc) / 16 */
 339     /* TCS = internal clock */
 340     /* enable */
 341
 342     /* enable the interrupt */
 343     interrupt_vector[2] = TIMER0;
 344     IMR0 |= (1<<2);
 345 }
 346
 347 #elif (CONFIG_CPU == PP5002) || (CONFIG_CPU == PP5020)
 348
 349 #ifndef BOOTLOADER
 350 void TIMER1(void)
 351 {
 352     int i;
 353
 354     TIMER1_VAL; /* Read value to ack IRQ */
 355     /* Run through the list of tick tasks */
 356     for (i = 0;i < MAX_NUM_TICK_TASKS;i++)
 357     {
 358         if (tick_funcs[i])
 359         {
 360             tick_funcs[i]();
 361         }
 362     }
 363
 364     current_tick++;
 365     wake_up_thread();
 366 }
 367 #endif
 368
 369 void tick_start(unsigned int interval_in_ms)
 370 {
 371 #ifndef BOOTLOADER
 372     TIMER1_CFG = 0x0;
 373     TIMER1_VAL;
 374     /* enable timer */
 375     TIMER1_CFG = 0xc0000000 | (interval_in_ms*1000);
 376     /* unmask interrupt source */
 377     CPU_INT_EN = TIMER1_MASK;
 378 #else
 379     /* We don't enable interrupts in the bootloader */
 380     (void)interval_in_ms;
 381 #endif
 382 }
 383
 384 #elif CONFIG_CPU == PNX0101
 385
 386 void timer_handler(void)
 387 {
 388     int i;
 389
 390     /* Run through the list of tick tasks */
 391     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 392     {
 393         if(tick_funcs[i])
 394             tick_funcs[i]();
 395     }
 396
 397     current_tick++;
 398     wake_up_thread();
 399
 400     TIMERR0C = 1;
 401 }
 402
 403 void tick_start(unsigned int interval_in_ms)
 404 {
 405   TIMERR08 &= ~0x80;
 406   TIMERR0C = 1;
 407   TIMERR08 &= ~0x80;
 408   TIMERR08 |= 0x40;
 409   TIMERR00 = 3000000 * interval_in_ms / 1000;
 410   TIMERR08 &= ~0xc;
 411   TIMERR0C = 1;
 412
 413   irq_set_int_handler(4, timer_handler);
 414   irq_enable_int(4);
 415
 416   TIMERR08 |= 0x80;
 417 }
 418
 419 #endif
 420
 421 int tick_add_task(void (*f)(void))
 422 {
 423     int i;
 424     int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
 425
 426     /* Add a task if there is room */
 427     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 428     {
 429         if(tick_funcs[i] == NULL)
 430         {
 431             tick_funcs[i] = f;
 432             set_irq_level(oldlevel);
 433             return 0;
 434         }
 435     }
 436     set_irq_level(oldlevel);
 437     panicf("Error! tick_add_task(): out of tasks");
 438     return -1;
 439 }
 440
 441 int tick_remove_task(void (*f)(void))
 442 {
 443     int i;
 444     int oldlevel = set_irq_level(HIGHEST_IRQ_LEVEL);
 445
 446     /* Remove a task if it is there */
 447     for(i = 0;i < MAX_NUM_TICK_TASKS;i++)
 448     {
 449         if(tick_funcs[i] == f)
 450         {
 451             tick_funcs[i] = NULL;
 452             set_irq_level(oldlevel);
 453             return 0;
 454         }
 455     }
 456
 457     set_irq_level(oldlevel);
 458     return -1;
 459 }
 460
 461 #ifndef SIMULATOR
 462 /*
 463  * Simulator versions in uisimulator/SIMVER/
 464  */
 465
 466 /****************************************************************************
 467  * Simple mutex functions
 468  ****************************************************************************/
 469 void mutex_init(struct mutex *m)
 470 {
 471     m->locked = false;
 472 }
 473
 474 void mutex_lock(struct mutex *m)
 475 {
 476     /* Wait until the lock is open... */
 477     while(m->locked)
 478         sleep_thread();
 479     wake_up_thread();
 480
 481     /* ...and lock it */
 482     m->locked = true;
 483 }
 484
 485 void mutex_unlock(struct mutex *m)
 486 {
 487     m->locked = false;
 488 }
 489
 490 #endif