scheduler.h

Jan 04, 2007 1. Add SPI support, see spi.h and spi.c 2. Add driver.h 3. Modified keyboard modu

/**
 * Copyright (c) 2006-2008 iWESUN (ShenZhen) Inf.
 * All rights reserved. 
 * 
 * Redistribution and use in source and binary forms, with or without modification, 
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission. 
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
 * OF SUCH DAMAGE.
 *
 * This file is part of the AvrcX MTOS
 * 
 * Author: Winter Hu  <[e-mail]>
 * Create: Nov 27, 2006
 */

#ifndef __SCHEDULER_H__
#define __SCHEDULER_H__

#include "common.h"
#include "lnklist.h"
#include "hardware.h"

/* Use Timer0 system tick */
#ifndef TICKRATE
#define TICKRATE 1000
#endif
#define TCNT0_INIT  (0xFF-(F_CPU/256/TICKRATE)) // 1ms


/* __AVR__*/
#define MINCONTEXT 35    // 32 registers, return address and SREG

#define USER_MODE  0xFF
#define MAX_WAIT_TICKS 250 // MUST less than 0xFF

/* Process Status */
#define TASK_READY   0x00    // Task is running or is ready in RunQueue
#define TASK_BLOCK   0x01    // Task is blocked in BlockedQueue of semaphore
#define TASK_DELAY   0x02    // Task is delay in TimerQueue

#ifndef __ASSEMBLER__
/* These only work in C program */

typedef Node PID; // PID.pData-->PCB

typedef Node TID; // TID.pData-->TSTimer

typedef struct TSTimer {
  PID* pid;
  __volatile__ unsigned short ticks;
} TSTimer;

// Define Process Control Block
typedef struct ProcessControlBlock {
  __volatile__ unsigned char status;    // Process Status Word
  __volatile__ unsigned char priority;  // Predefined priority
  __volatile__ unsigned char tmslices;  // Predefined time slice
  __volatile__ unsigned char reserved;
  void* context; // Process Context Pointer, i.e. Stack Pointer
  TSTimer timer;
  TID tid;
} PCB;

// Define Task Control Block which are stored in FLASH memory
typedef struct TaskControlBlock {
  void *stack;             // Start of stack
  void (*start) (void);    // Entry point of code
  PCB  *pcb;               // Pointer to the Process Control Block
  PID  *pid;               // Pointer to the Process Node
  unsigned char priority;  // Predefined priority of task (0~255)
  unsigned char tmslices;  // Predefined time slice of task (0~255)
} FLASH const TCB;

/**
 * A macro to ease the declaration of tasks definition.
 * Usage: TASKDEF(myFoo, 10, 16, 10)
 *
 * @param start, The name of the task function
 * @param n_stack, The bytes of this task maybe use
 * @param priority, The task priority
 * @param slice, The task time slice
 */
#define TASKDEF(start, n_stack, priority, slice)        \
  CTASKFUNC(start)                                      \
  char start##_stack[n_stack + MINCONTEXT];		\
  PCB start##_pcb;					\
  PID start##_pid;					\
  TCB start##_tcb = {					\
    &start##_stack[sizeof(start##_stack) - 1],          \
    start,                                              \
    &start##_pcb,                                       \
    &start##_pid,                                       \
    priority,					        \
    slice                                               \
  }

/**
 * Return the pointer to the task PID 
 *
 * @param start, The name of the task 
 */
#define getPID(start) &start##_pid

/**
 * Return the ponter to the task PCB
 *
 * @param start, The name of the task 
 */
#define getPCB(start) &start##_pcb

/**
 * Return the pointer to the task TCB
 *
 * @param start, The name of the task
 */
#define getTCB(start) &start##_tcb

// Define Kernel Data
typedef struct KernelData{
  LinkedList RunQueue;     // The ready queue
  LinkedList TimerQueue;   // The timer queue
  LinkedList *BlockedQueue;  // The blocked queue
  PID  *Running;           // Current running process
  void *Context;           // Kernel context
  __volatile__ unsigned char TmSlices;  // Remaining time ticks of current process
  __volatile__ unsigned char SysLevel;  // Re-entry counter into kernel context
                           // user mode is 0xFF
  unsigned long SysTicks;
} KernelData;

extern KernelData kernel;
/**
 * Initizlize Scheduler
 * This must be invoked before tasks schedulling
 */
INTERFACE void init_scheduler(void);

/**
 * Start scheduler
 * This method never return
 */
INTERFACE void NAKED start(void);

/**
 * Create the task PID of specified TCB
 *
 * @param TCB*, The pointer to the Task Control Block
 * @return PID*, The pointer to the Task PID
 * @see "scheduler.asm.S"
 */
INTERFACE PID* create_task(TCB*);

/**
 * Create and resume the task into RunQueue
 * 
 * @param TCB*, The pointer to the Task Control Block
 */
INTERFACE void run_task(TCB*);

/**
 * Retrieves current running task
 *
 * @return PID*, the pointer to the current running task PID
 */
INTERFACE PID* get_running(void);

/**
 * Retreives system ticks
 *
 * @return unsigned long, The ticks from power on
 */
INTERFACE unsigned long get_systicks(void);

/**
 * Causes the currently executing task to temporarily pause and allow 
 * other tasks to execute.
 */
INTERFACE void NAKED yield(void);

/**
 * Causes the currently executing task to temporarily pause in TimQueue
 * until delay expire. 
 *
 * @param unsigned int, Ticks for sleeping
 */
INTERFACE void NAKED sleep(unsigned int);

/**
 * Swap the first PID from RunQueue to current env
 */
void swapping(void);

/**
 * Insert the PID into RunQueue
 *
 * @param PID*, The pointer to the PID
 */
void resume_task(PID*);

/**
 * Insert the PID into TimerQueue
 *
 * @param PID*, The pointer to the PID
 * @param unsigned int, The ticks to delay
 */
void delay_task(PID*, unsigned int);

/**
 * Pushes entire register context onto the current stack
 * SysLevel >= 0, running on kernel stack
 *
 * @see "scheduler.asm.S"
 */
void NAKED prologue(void);

/**
 * Restore previous context (kernel or user)
 * Ref. "scheduler.asm.S"
 *
 * ASSUMES:    SysLevel >= 0, running on kernel stack
 */
void NAKED epilogue(void);

#endif /* !__ASSEMBLER__ */

/* Kernel data structure offsets */
#define KERN_RUNQUEUE  0        // Head of the ready queue
#define KERN_TIMQUEUE  2        // Head of the timer queue
#define KERN_BLKQUEUE  4        // Head of the blocked queue
#define KERN_RUNNING   6        // Current running task
#define KERN_CONTEXT   8        // Kernel stack SP
#define KERN_TMSLICES 10        // Remaining time ticks of current task
#define KERN_SYSLEVEL 11        // User mode or Kernel mode
#define KERN_SYSTICKS 12        // A long integer of system tick counts
/* Process Control Block data structure offsets */
#define PCB_STATUS     0
#define PCB_PRIORITY   1
#define PCB_TMSLICES   2
#define PCB_CONTEXT    4
#define PCB_TIMER      6
#define PCB_TIMER_TICK 8
#endif /* __SCHEDULER_H__ */